¿Cómo puedo perfilar un script de shell?

Tengo varios programas que estoy ejecutando en un script de shell:

./myprogram1
./myprogram2
...

Sé que puedo perfilar cada programa individual editando el código fuente, pero quería saber si había una manera de medir el tiempo total ejecutado al perfilar el script en sí. ¿Hay un programa de temporizador que pueda usar para este propósito? Si es así, ¿qué tan precisa es su medición?

Comience usando el tiempo según la sugerencia de Jon Lin:

$ time ls test
test

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

No dice en qué unix se están ejecutando sus scripts, sino que se ejecuta en Linux, truss en Solaris / AIX, y creo que susc en hp-ux le permiten aprender mucho sobre lo que está haciendo un proceso. Me gusta la opción -c de strace para obtener un buen resumen:

]$ 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

También tenga en cuenta que adjuntar estos programas de tipo de rastreo puede ralentizar un poco el programa.

Mira el timecomando . Puede usarlo para medir el tiempo que se tarda en ejecutar junto con otra información útil, como dónde se está gastando el tiempo.

No es exactamente un perfil, pero puede rastrear su script mientras se ejecuta. Poner set -xvantes de la sección que desea rastrear y set +xvdespués de la sección. set -xhabilita xtrace, que mostrará cada línea que se ejecuta. set -vhabilita el modo detallado, que también mostrará líneas que pueden tener un efecto, pero que no se ejecutan, como la asignación de variables.

También puede marcar su rastro en el tiempo. Necesita un emulador de terminal que pueda marcar cada línea; el único que conozco es RealTerm , que es un programa de Windows, pero funcionará con Wine. También puede usarlo grabserial, aunque no lo he probado, excepto con puertos seriales reales. Puede averiguar qué dispositivo serie está usando su shell ejecutando ps -p $$(si no lo hace, use manpara averiguar cómo incluir la columna TTY en su pssalida).

Además, consulte Herramientas de creación de perfiles de rendimiento para scripts de shell en Stack Overflow.

time por varias iteraciones

Perfilado ejecutando el mismo comando varias veces

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

Donde echo "scale=1000; 4*a(1)" | bc -lcalcula pi y time (...)asegura que el forciclo se ejecute como un solo comando.

Como terminé aquí al menos dos veces, implementé una solución:

https://github.com/walles/shellprof

Ejecuta su secuencia de comandos, registra de forma transparente todas las líneas impresas y al final imprime una lista de las 10 líneas principales que estuvieron en pantalla durante más tiempo:

~/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|✔) $