Qual è il modo più veloce per eseguire uno script?

Mi chiedevo quale sia il modo più veloce per eseguire uno script, sto leggendo che c'è una differenza di velocità tra mostrare l'output dello script sul terminale, reindirizzarlo su un file o forse /dev/null.

Quindi, se l'output non è importante, qual è il modo più veloce per far funzionare lo script più velocemente, anche se è minimo.

bash ./myscript.sh 
-or-
bash ./myscript.sh > myfile.log
-or-
bash ./myscript.sh > /dev/null

Oggi i terminali sono più lenti di quanto non fossero in passato, principalmente perché le schede grafiche non si preoccupano più dell'accelerazione 2D. Pertanto, la stampa su un terminale può rallentare uno script, in particolare quando è coinvolto lo scorrimento.

Di conseguenza ./script.shè più lento di ./script.sh >script.log, che a sua volta è più lento di /script.sh >/dev/null, perché quest'ultimo comporta meno lavoro. Tuttavia, se questo fa abbastanza differenza per qualsiasi scopo pratico dipende dalla quantità di output prodotta dallo script e dalla velocità. Se lo script scrive 3 righe ed esce, o se stampa 3 pagine ogni poche ore, probabilmente non dovrai preoccuparti dei reindirizzamenti.

Modifica: alcuni benchmark rapidi (e completamente rotti):

• In una console Linux, 240x75:

  $ time (for i in {1..100000}; do echo $i 01234567890123456789012345678901234567890123456789; done)
  real    3m52.053s
  user    0m0.617s
  sys     3m51.442s

• In un xterm, 260x78:

  $ time (for i in {1..100000}; do echo $i 01234567890123456789012345678901234567890123456789; done)
  real    0m1.367s
  user    0m0.507s
  sys     0m0.104s

• Reindirizzamento a un file, su un disco Samsung SSD 850 PRO da 512 GB:

   $ time (for i in {1..100000}; do echo $i 01234567890123456789012345678901234567890123456789; done >file)
   real    0m0.532s
   user    0m0.464s
   sys     0m0.068s

• Reindirizzare a /dev/null:

   $ time (for i in {1..100000}; do echo $i 01234567890123456789012345678901234567890123456789; done >/dev/null)
   real    0m0.448s
   user    0m0.432s
   sys     0m0.016s

Avrei istintivamente concordato con la risposta di Satō Katsura; ha senso. Tuttavia, è abbastanza facile da testare.

Ho testato la scrittura di un milione di righe sullo schermo, la scrittura (aggiunta) a un file e il reindirizzamento a /dev/null. Ho testato ciascuno di questi a turno, quindi ho fatto cinque repliche. Questi sono i comandi che ho usato.

$ time (for i in {1..1000000}; do echo foo; done)
$ time (for i in {1..1000000}; do echo foo; done > /tmp/file.log) 
$ time (for i in {1..1000000}; do echo foo; done > /dev/null)

Ho quindi tracciato i tempi totali di seguito.

Come puoi vedere, le presunzioni di Satō Katsura erano corrette. Secondo la risposta di Satō Katsura, dubito anche che il fattore limitante sarà l'output, quindi è improbabile che la scelta dell'output abbia un effetto sostanziale sulla velocità complessiva dello script.

FWIW, la mia risposta originale aveva un codice diverso, che aveva il file aggiunto e /dev/nullreindirizzato all'interno del ciclo.

$ rm /tmp/file.log; touch /tmp/file.log; time (for i in {1..1000000}; do echo foo >> /tmp/file.log; done) 
$ time (for i in {1..1000000}; do echo foo > /dev/null; done)

Come sottolinea John Kugelman nei commenti, ciò aggiunge molte spese generali. Allo stato attuale della domanda, questo non è davvero il modo giusto per testarlo, ma lo lascerò qui perché mostra chiaramente il costo di riaprire un file ripetutamente all'interno dello script stesso.

In questo caso, i risultati sono invertiti.

Un altro modo per velocizzare uno script è usare un interprete di shell più veloce. Confronta le velocità di un loop occupato POSIX , esegui in bash v4.4 , ksh v93u + 20120801 e dash v0.5.8 .

1. bash:

   time echo 'n=0;while [ $n -lt 1000000 ] ; do \
                     echo $((n*n*n*n*n*n*n)) ; n=$((n+1)); 
                  done' | bash -s > /dev/null

   Produzione:

   real    0m25.146s
   user    0m24.814s
   sys 0m0.272s

2. ksh:

   time echo 'n=0;while [ $n -lt 1000000 ] ; do \
                     echo $((n*n*n*n*n*n*n)) ; n=$((n+1)); 
                  done' | ksh -s > /dev/null

   Produzione:

   real    0m11.767s
   user    0m11.615s
   sys 0m0.010s

3. dash:

   time echo 'n=0;while [ $n -lt 1000000 ] ; do \
                     echo $((n*n*n*n*n*n*n)) ; n=$((n+1)); 
                  done' | dash -s > /dev/null

   Produzione:

   real    0m4.886s
   user    0m4.690s
   sys 0m0.184s

Un sottoinsieme di comandi in bashe kshsono retrocompatibili con tutti i comandi in dash. Uno bashscript che utilizza solo comandi in quel sottoinsieme dovrebbe funzionare con dash.

Alcuni bashscript che utilizzano nuove funzionalità possono essere convertiti in un altro interprete. Se lo bashscript si basa fortemente su nuove funzionalità, potrebbe non valere la pena di preoccuparsene - alcune nuove bashfunzionalità sono miglioramenti che sono sia più facili da codificare sia più efficienti (anche se bashgeneralmente più lenti), quindi l' dashequivalente (che potrebbe comportare l'esecuzione molti altri comandi), sarebbe più lento.

In caso di dubbio, esegui un test ...