Como obter tempo de execução de um script efetivamente?

Gostaria de exibir o tempo de conclusão de um script.

O que eu faço atualmente é -

#!/bin/bash
date  ## echo the date at start
# the script contents
date  ## echo the date at end

Isso mostra apenas a hora do início e do fim do script. Seria possível exibir uma saída refinada, como tempo do processador / tempo io, etc?

Basta usar timequando você chamar o script:

time yourscript.sh

Se timenão for uma opção,

start=`date +%s`
stuff
end=`date +%s`

runtime=$((end-start))

Basta ligar timessem argumentos ao sair do seu script.

Com kshou zsh, você também pode usar time. Com zsh, timetambém fornecerá a hora do relógio de parede, além da hora da CPU do usuário e do sistema .

Para preservar o status de saída do seu script, você pode:

ret=$?; times; exit "$ret"

Ou você também pode adicionar uma armadilha em EXIT:

trap times EXIT

Dessa forma, os horários serão chamados sempre que o shell sair e o status de saída for preservado.

$ bash -c 'trap times EXIT; : {1..1000000}'
0m0.932s 0m0.028s
0m0.000s 0m0.000s
$ zsh -c 'trap time EXIT; : {1..1000000}'
shell  0.67s user 0.01s system 100% cpu 0.677 total
children  0.00s user 0.00s system 0% cpu 0.677 total

Observe também que todos bash, kshe zshtem uma $SECONDSvariável especial que automaticamente é incrementado a cada segundo. Em ambos zshe ksh93, essa variável também pode ser feita de ponto flutuante (com typeset -F SECONDS) para obter mais precisão. Esta é apenas a hora do relógio de parede, não da CPU.

Estou um pouco atrasado para o movimento, mas queria postar minha solução (para precisão de menos de um segundo), caso outras pessoas encontrassem esse tópico através da pesquisa. A saída está no formato de dias, horas, minutos e finalmente segundos:

res1=$(date +%s.%N)

# do stuff in here

res2=$(date +%s.%N)
dt=$(echo "$res2 - $res1" | bc)
dd=$(echo "$dt/86400" | bc)
dt2=$(echo "$dt-86400*$dd" | bc)
dh=$(echo "$dt2/3600" | bc)
dt3=$(echo "$dt2-3600*$dh" | bc)
dm=$(echo "$dt3/60" | bc)
ds=$(echo "$dt3-60*$dm" | bc)

printf "Total runtime: %d:%02d:%02d:%02.4f\n" $dd $dh $dm $ds

Espero que alguém ache isso útil!

Meu método para bash:

# Reset BASH time counter
SECONDS=0
    # 
    # do stuff
    # 
ELAPSED="Elapsed: $(($SECONDS / 3600))hrs $((($SECONDS / 60) % 60))min $(($SECONDS % 60))sec"

#!/bin/bash
start=$(date +%s.%N)

# HERE BE CODE

end=$(date +%s.%N)    
runtime=$(python -c "print(${end} - ${start})")

echo "Runtime was $runtime"

Sim, isso chama Python, mas se você pode conviver com isso, é uma solução concisa e agradável.

Esta pergunta é bastante antiga, mas, ao tentar encontrar minha maneira favorita de fazer isso, esta discussão surgiu ... e estou surpreso que ninguém tenha mencionado:

perf stat -r 10 -B sleep 1

'perf' é uma ferramenta de análise de desempenho incluída no kernel em 'tools / perf' e frequentemente disponível para instalação como um pacote separado ('perf' no CentOS e 'linux-tools' no Debian / Ubuntu). O Linux Kernal perf Wiki tem muito mais informações sobre ele.

A execução do 'perf stat' fornece vários detalhes, incluindo o tempo médio de execução no final:

1.002248382 seconds time elapsed                   ( +-  0.01% )

Uma pequena função de shell que pode ser adicionada antes dos comandos para medir seu tempo:

tm() {
  s=$(date +%s)
  $@
  rc=$?
  echo "took $[$(date +%s)-$s] seconds. return code $rc" >&2
  return $rc
}

Em seguida, use-o no seu script ou na sua linha de comando da seguinte maneira:

tm the_original_command with all its parameters

Aqui está uma variação da resposta de Alex. Eu me importo apenas com minutos e segundos, mas também queria que ele fosse formatado de maneira diferente. Então eu fiz isso:

start=$(date +%s)
end=$(date +%s)
runtime=$(python -c "print '%u:%02u' % ((${end} - ${start})/60, (${end} - ${start})%60)")

#!/bin/csh
#PBS -q glean
#PBS -l nodes=1:ppn=1
#PBS -l walltime=10:00:00
#PBS -o a.log
#PBS -e a.err
#PBS -V
#PBS -M [email protected]
#PBS -m abe
#PBS -A k4zhang-group
START=$(date +%s)
for i in {1..1000000}
do
echo 1
done
END=$(date +%s)
DIFF=$(echo "$END - $START" | bc)
echo "It takes DIFF=$DIFF seconds to complete this task..."

Usando apenas o bash, também é possível medir e calcular a duração do tempo para uma parte do script shell (ou o tempo decorrido para o script inteiro):

start=$SECONDS

... # do time consuming stuff

end=$SECONDS

agora você pode simplesmente imprimir a diferença:

echo "duration: $((end-start)) seconds."

se você precisar apenas de duração incremental, faça:

echo "duration: $((SECONDS-start)) seconds elapsed.."

Você também pode armazenar a duração em uma variável:

let diff=end-start

Pessoalmente, eu gosto de agrupar todo o meu código de script em alguma função "principal" como:

main () {
 echo running ...
}

# stuff ...

# calling the function at the very end of the script
time main

Observe como é fácil usar o timecomando neste cenário. Obviamente, você não está medindo o tempo exato, incluindo o tempo de análise de script, mas acho preciso o suficiente na maioria das situações.

#!/bin/bash
begin=$(date +"%s")

Script

termin=$(date +"%s")
difftimelps=$(($termin-$begin))
echo "$(($difftimelps / 60)) minutes and $(($difftimelps % 60)) seconds elapsed for Script Execution."

A função de tempo baseada em SECONDS, limitada apenas à granularidade de segundo nível, não usa nenhum comando externo:

time_it() {
  local start=$SECONDS ts ec
  printf -v ts '%(%Y-%m-%d_%H:%M:%S)T' -1
  printf '%s\n' "$ts Starting $*"
  "$@"; ec=$?
  printf -v ts '%(%Y-%m-%d_%H:%M:%S)T' -1
  printf '%s\n' "$ts Finished $*; elapsed = $((SECONDS-start)) seconds"
  # make sure to return the exit code of the command so that the caller can use it
  return "$ec"
}

Por exemplo:

time_it sleep 5

dá

2019-03-30_17:24:37 Starting sleep 5 2019-03-30_17:24:42 Finished
sleep 5; elapsed = 5 seconds