Come posso profilare uno script di shell?

Ho diversi programmi che sto eseguendo in uno script di shell:

./myprogram1
./myprogram2
...

So che posso profilare ogni singolo programma modificando il codice sorgente, ma volevo sapere se c'era un modo per misurare il tempo totale eseguito profilando lo script stesso. Esiste un programma timer che posso usare per questo scopo? In tal caso, quanto è precisa la sua misurazione?

Inizia usando il tempo secondo il suggerimento di Jon Lin:

$ time ls test
test

real    0m0.004s
user    0m0.002s
sys     0m0.002s

Non dite su cosa unix stiano eseguendo i vostri script, ma andate su Linux, truss su Solaris / AIX e penso che tusc su hp-ux vi faccia imparare molto su ciò che sta facendo un processo. Mi piace l'opzione -c di strace per ottenere un bel riassunto:

]$ strace -c ls
test
% time     seconds  usecs/call     calls    errors syscall
------ ----------- ----------- --------- --------- ----------------
 89.19    0.000998         998         1           execve
 10.81    0.000121         121         1           write
  0.00    0.000000           0        12           read
  0.00    0.000000           0        93        79 open
  0.00    0.000000           0        16           close
  0.00    0.000000           0         2         1 access
  0.00    0.000000           0         3           brk
  0.00    0.000000           0         2           ioctl
  0.00    0.000000           0         4           munmap
  0.00    0.000000           0         1           uname
  0.00    0.000000           0         6           mprotect
  0.00    0.000000           0         2           rt_sigaction
  0.00    0.000000           0         1           rt_sigprocmask
  0.00    0.000000           0         1           getrlimit
  0.00    0.000000           0        30           mmap2
  0.00    0.000000           0         8         7 stat64
  0.00    0.000000           0        13           fstat64
  0.00    0.000000           0         2           getdents64
  0.00    0.000000           0         1           fcntl64
  0.00    0.000000           0         1           futex
  0.00    0.000000           0         1           set_thread_area
  0.00    0.000000           0         1           set_tid_address
  0.00    0.000000           0         1           set_robust_list
  0.00    0.000000           0         1           socket
  0.00    0.000000           0         1         1 connect
------ ----------- ----------- --------- --------- ----------------
100.00    0.001119                   205        88 total

Si noti inoltre che il collegamento di questi programmi di tipo di traccia può rallentare leggermente il programma.

Dai un'occhiata al timecomando . Puoi usarlo per misurare il tempo necessario per l'esecuzione insieme ad alcune altre informazioni utili come dove il tempo è trascorso.

Non è esattamente la profilazione, ma puoi tracciare il tuo script mentre viene eseguito. Metti set -xvprima della sezione che vuoi tracciare e set +xvdopo la sezione. set -xabilita xtrace, che mostrerà ogni riga che viene eseguita. set -vabilita la modalità dettagliata, che mostrerà anche le linee che possono avere un effetto, ma non vengono eseguite, come l'assegnazione delle variabili.

Puoi anche timestamp della tua traccia. È necessario un emulatore di terminale in grado di timestampare ogni riga; l'unico che conosco è RealTerm , che è un programma Windows, ma funzionerà con Wine. Potresti anche essere in grado di utilizzare grabserial, anche se non l'ho provato se non con porte seriali reali. Puoi scoprire quale dispositivo seriale sta usando la tua shell eseguendo ps -p $$(in caso contrario, usa manper scoprire come includere la colonna TTY psnell'output).

Vedere anche Strumenti di profilazione delle prestazioni per gli script di shell su StackTranslate.it.

time per diverse iterazioni

Creazione del profilo eseguendo lo stesso comando più volte

time (for ((n=0;n<10;n++)); do echo "scale=1000; 4*a(1)" | bc -l; done)

Dove echo "scale=1000; 4*a(1)" | bc -lcalcola pi e time (...)garantisce che il forciclo venga eseguito come un singolo comando.

Da quando sono finito qui almeno due volte, ho implementato una soluzione:

https://github.com/walles/shellprof

Esegue lo script, esegue il clock in modo trasparente di tutte le righe stampate e alla fine stampa un elenco delle prime 10 linee che erano le più lunghe sullo schermo:

~/s/shellprof (master|✔) $ ./shellprof ./testcase.sh
quick
slow
quick

Timings for printed lines:
1.01s: slow
0.00s: <<<PROGRAM START>>>
0.00s: quick
0.00s: quick
~/s/shellprof (master|✔) $