¿Cómo obtener el tiempo de ejecución de un script de manera efectiva?

Me gustaría mostrar el tiempo de finalización de un script.

Lo que hago actualmente es

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

Esto solo muestra la hora de inicio y finalización del guión. ¿Sería posible mostrar una salida de grano fino como tiempo de procesador / tiempo io, etc.?

Solo use timecuando llame al script:

time yourscript.sh

Si timeno es una opción,

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

runtime=$((end-start))

Simplemente llame timessin argumentos al salir de su script.

Con ksho zsh, también puede usar timeen su lugar. Con zsh, timetambién le dará el tiempo de reloj de pared además del tiempo de CPU del usuario y del sistema .

Para preservar el estado de salida de su script, puede hacerlo:

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

O también puede agregar una trampa en EXIT:

trap times EXIT

De esa manera, se llamarán los tiempos cada vez que el shell salga y se conservará el estado de salida.

$ 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

También tenga en cuenta que todos bash, kshy zshtener una $SECONDSvariable especial que automáticamente se incrementa cada segundo. En ambos zshy ksh93, esa variable también se puede hacer punto flotante (con typeset -F SECONDS) para obtener más precisión. Este es solo el tiempo del reloj de pared, no el tiempo de la CPU.

Llego un poco tarde al tren, pero quería publicar mi solución (para una precisión de menos de un segundo) en caso de que otros tropiecen con este hilo a través de la búsqueda. La salida está en formato de días, horas, minutos y 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 alguien lo encuentre útil!

Mi 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"

Sí, esto se llama Python, pero si puedes vivir con eso, entonces esta es una solución bastante agradable y concisa.

Esta pregunta es bastante antigua, pero al tratar de encontrar mi forma favorita de hacerlo, este hilo surgió alto ... y me sorprende que nadie lo haya mencionado:

perf stat -r 10 -B sleep 1

'perf' es una herramienta de análisis de rendimiento incluida en el núcleo bajo 'tools / perf' y a menudo disponible para instalar como un paquete separado ('perf' en CentOS y 'linux-tools' en Debian / Ubuntu). El Linux Kernal perf Wiki tiene mucha más información al respecto.

Ejecutar 'perf stat' proporciona bastantes detalles, incluido el tiempo de ejecución promedio justo al final:

1.002248382 seconds time elapsed                   ( +-  0.01% )

Una pequeña función de shell que se puede agregar antes de los comandos para medir su tiempo:

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

Luego, úselo en su script o en su línea de comando de la siguiente manera:

tm the_original_command with all its parameters

Aquí hay una variación de la respuesta de Alex. Solo me importan los minutos y los segundos, pero también quería que tuviera un formato diferente. Entonces hice esto:

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 shihcheng.guo@gmail.com
#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 solo bash también es posible medir y calcular la duración del tiempo para una parte del script de shell (o el tiempo transcurrido para todo el script):

start=$SECONDS

... # do time consuming stuff

end=$SECONDS

ahora puede imprimir la diferencia:

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

si solo necesita una duración incremental, haga lo siguiente:

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

También puede almacenar la duración en una variable:

let diff=end-start

Personalmente, me gusta envolver todo mi código de script en alguna función "principal" de esta manera:

main () {
 echo running ...
}

# stuff ...

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

Observe lo fácil que es usar el timecomando en este escenario. Obviamente no estás midiendo el tiempo preciso, incluido el tiempo de análisis del script, pero lo encuentro lo suficientemente preciso en la mayoría de las situaciones.

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

Script

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

La función de temporización basada en SECONDS, limitada solo a granularidad de segundo nivel, no utiliza ningún 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 ejemplo:

time_it sleep 5

da

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