Como posso criar um perfil para um script de shell?

Eu tenho vários programas que estou executando em um script de shell:

./myprogram1
./myprogram2
...

Sei que posso criar um perfil de cada programa individual editando o código-fonte, mas queria saber se havia uma maneira de medir o tempo total executado, criando o perfil do próprio script. Existe um programa de timer que eu possa usar para esse fim? Se sim, qual a precisão da sua medição?

Comece usando o tempo conforme a sugestão de Jon Lin:

$ time ls test
test

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

Você não diz em que unix seus scripts estão rodando, mas sim no linux, truss no Solaris / AIX, e acho que o tusc no hp-ux permite que você aprenda muito sobre o que um processo está fazendo. Eu gosto da opção -c do strace para obter um bom resumo:

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

Observe também que anexar esses programas do tipo rastreamento pode atrasar um pouco o programa.

Confira o timecomando . Você pode usá-lo para medir o tempo necessário para executar, juntamente com outras informações úteis, como onde o tempo está sendo gasto.

Não é exatamente o perfil, mas você pode rastrear seu script enquanto ele é executado. Coloque set -xvantes da seção que deseja rastrear e set +xvdepois da seção. set -xativa o xtrace, que mostrará todas as linhas que são executadas. set -vativa o modo detalhado, que também mostrará linhas que podem ter efeito, mas não são executadas, como atribuição de variável.

Você também pode registrar o carimbo de data e hora. Você precisa de um emulador de terminal que possa registrar o carimbo de data / hora em todas as linhas; o único que eu conheço é o RealTerm , que é um programa do Windows, mas funcionará com o Wine. Você também pode usar grabserial, embora eu não tenha tentado, exceto com portas seriais reais. Você pode descobrir qual dispositivo serial seu shell está usando executando ps -p $$(caso contrário, use manpara descobrir como incluir a coluna TTY na sua pssaída).

Além disso, consulte Ferramentas de perfil de desempenho para scripts de shell no Stack Overflow.

time para várias iterações

Criação de perfil executando o mesmo comando várias vezes

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

Onde echo "scale=1000; 4*a(1)" | bc -lcalcula pi e time (...)garante que o forloop seja executado como um único comando.

Desde que acabei aqui pelo menos duas vezes agora, implementei uma solução:

https://github.com/walles/shellprof

Ele executa seu script, mostra de forma transparente todas as linhas impressas e, no final, imprime uma lista das 10 principais das linhas que estavam mais longas na tela:

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