Cómo medir el tiempo de ejecución del programa y almacenarlo dentro de una variable

Para saber cuánto tiempo tardan ciertas operaciones dentro de un script Bash (v4 +), me gustaría analizar el resultado del timecomando "por separado" y (en última instancia) capturarlo dentro de una variable Bash ( let VARNAME=...).

Ahora, estoy usando time -f '%e' ...(o más bien command time -f '%e' ...debido al Bash incorporado), pero dado que ya redirijo la salida del comando ejecutado, realmente estoy perdido en cuanto a cómo capturaría la salida del timecomando. Básicamente, el problema aquí es separar la salida de timela salida de los comandos ejecutados.

Lo que quiero es la funcionalidad de contar la cantidad de tiempo en segundos (enteros) entre el inicio de un comando y su finalización. No tiene que ser el timecomando o el respectivo incorporado.

Editar: dadas las dos respuestas útiles a continuación, quería agregar dos aclaraciones.

1. No quiero tirar la salida del comando ejecutado, pero realmente no importará si termina en stdout o stderr.
2. Preferiría un enfoque directo sobre uno indirecto (es decir, capturar la salida directamente en lugar de almacenarla en archivos intermedios).

La solución que utilizo datehasta ahora se cierra a lo que quiero.

Para obtener la salida de timeen una var, use lo siguiente:

usr@srv $ mytime="$(time ( ls ) 2>&1 1>/dev/null )"
usr@srv $ echo "$mytime"

real    0m0.006s
user    0m0.001s
sys     0m0.005s

También puede solicitar un solo tipo de hora, por ejemplo, utime:

usr@srv $ utime="$( TIMEFORMAT='%lU';time ( ls ) 2>&1 1>/dev/null )"
usr@srv $ echo "$utime"
0m0.000s

Para obtener el tiempo que también puede usar date +%s.%N, tómelo antes y después de la ejecución y calcule la diferencia:

START=$(date +%s.%N)
command
END=$(date +%s.%N)
DIFF=$(echo "$END - $START" | bc)
# echo $DIFF

En bash, el resultado de la timeconstrucción va a su error estándar, y puede redirigir el error estándar de la tubería que afecta. Así que vamos a empezar con un comando que escribe a sus streamas de salida y de error: sh -c 'echo out; echo 1>&2 err'. Para no mezclar la secuencia de error del comando con la salida de time, podemos desviar temporalmente la secuencia de error del comando a un descriptor de archivo diferente:

{ time -p sh -c 'echo out; echo 1>&2 err' 2>&3; }

Esto escribe outen fd 1, erren fd 3 y los tiempos en fd 2:

{ time -p sh -c 'echo out; echo 1>&2 err' 2>&3; } \
    3> >(sed 's/^/ERR:/') 2> >(sed 's/^/TIME:/') > >(sed 's/^/OUT:/')

Sería más agradable tenerlo erren fd 2 y las veces en fd 3, por lo que los intercambiamos, lo cual es engorroso porque no hay una forma directa de intercambiar dos descriptores de archivo:

{ { { time -p sh -c 'echo out; echo 1>&2 err' 2>&3; } 3>&2 2>&4; } 4>&3; } 3> >(sed 's/^/TIME:/') 2> >(sed 's/^/ERR:/') > >(sed 's/^/OUT:/')

Esto muestra cómo puede postprocesar la salida del comando, pero si desea capturar tanto la salida del comando como sus tiempos, debe trabajar más duro. Usar un archivo temporal es una solución. De hecho, es la única solución confiable si necesita capturar tanto el error estándar del comando como su salida estándar. Pero de lo contrario, puede capturar todo el resultado y aprovechar el hecho de que timetiene un formato predecible (si lo usa time -ppara obtener el formato POSIX o la TIMEFORMATvariable específica de bash ).

nl=$'\n'
output=$(TIMEFORMAT='%R %U %S %P'; mycommand)
set ${output##*$nl}; real_time=$1 user_time=$2 system_time=$3 cpu_percent=$4
output=${output%$nl*}

Si solo le importa el tiempo del reloj de pared, la ejecución dateantes y después es una solución simple (si es un poco más imprecisa debido al tiempo extra dedicado a cargar el comando externo).

Con el tiempo, la salida del comando sale en stdout y el tiempo sale en stderr. Entonces, para separarlos, puedes hacer:

command time -f '%e' [command] 1>[command output file] 2>[time output file]

Pero, ahora el tiempo está en un archivo. No creo que Bash pueda poner stderr en una variable directamente. Si no le importa redirigir la salida del comando a alguna parte, puede hacer lo siguiente:

FOO=$((( command time -f '%e' [command]; ) 1>outputfile; ) 2>&1; )

Cuando haga esto, la salida del comando estará activada outputfiley el tiempo que tardó en ejecutarse $FOO.

Si está bash(y no sh) y NO necesita una precisión de menos de un segundo, puede omitir la llamada por datecompleto y hacerlo sin generar ningún proceso adicional, sin tener que separar la salida combinada y sin tener que capturar y analizar la salida de cualquier comando:

# SECONDS is a bash special variable that returns the seconds since set.
SECONDS=0
mycmd <infile >outfile 2>errfile
DURATION_IN_SECONDS=$SECONDS
# Now `$DURATION_IN_SECONDS` is the number of seconds.

Para ese propósito, probablemente sea mejor usar times(que time) en el bashque imprime el usuario acumulado y los tiempos del sistema para el shell y para los procesos ejecutados desde el shell, por ejemplo use:

$ (sleep 2; times) | (read tuser tsys; echo $tuser:$tsys)
0m0.001s:0m0.003s

Ver: help -m timespara más información.

Al poner todas las respuestas anteriores juntas, cuando en OSX

ProductName:    Mac OS X
ProductVersion: 10.11.6
BuildVersion:   15G31+

puedes hacer como

microtime() {
    python -c 'import time; print time.time()'
}
compute() {
    local START=$(microtime)
    #$1 is command $2 are args
    local END=$(microtime)
    DIFF=$(echo "$END - $START" | bc)
    echo "$1\t$2\t$DIFF"
}

Instalar /bin/time(por ejemplo pacman -S time)

Entonces, en lugar de error al intentar -fmarcar:

$ time -f %e sleep 0.5
bash: -f: command not found

real    0m0.001s
user    0m0.001s
sys     0m0.001s

Realmente puedes usarlo:

$ /bin/time -f %e sleep 0.5
0.50

Y obtenga lo que desea: tiempo en variable (ejemplo, usos %epara el tiempo transcurrido real, para otras opciones de verificación man time):

#!/bin/bash
tmpf="$(mktemp)"
/bin/time -f %e -o "$tmpf" sleep 0.5
variable="$(cat "$tmpf")"
rm "$tmpf"

echo "$variable"

Solo como un aviso al trabajar con las declaraciones anteriores y especialmente teniendo en cuenta la respuesta de Grzegorz. Me sorprendió ver en mi sistema Ubuntu 16.04 Xenial estos dos resultados:

$ which time
/usr/bin/time

$ time -f %e sleep 4
-f: command not found
real    0m0.071s
user    0m0.056s
sys     0m0.012s

$ /usr/bin/time -f %e sleep 4
4.00

No tengo ningún alias establecido, por lo que no sé por qué sucede esto.

intente esto, ejecuta un comando simple con argumentos y pone los tiempos $ real $ user $ sys y conserva el código de salida.

Tampoco bifurca subcapas ni pisotea ninguna variable, excepto el sistema de usuario real, y no interfiere con la ejecución del script

timer () {
  { time { "$@" ; } 2>${_} {_}>&- ; } {_}>&2 2>"/tmp/$$.$BASHPID.${#FUNCNAME[@]}"
  set -- $?
  read -d "" _ real _ user _ sys _ < "/tmp/$$.$BASHPID.${#FUNCNAME[@]}"
  rm -f "/tmp/$$.$BASHPID.${#FUNCNAME[@]}"
  return $1
}

p.ej

  timer find /bin /sbin /usr rm /tmp/
  echo $real $user $sys

nota: solo mide el tiempo del comando simple, no una tubería, cuyos componentes se ejecutan en una subshell

Esta versión le permite especificar como $ 1 el nombre de las variables que deberían recibir las 3 veces:

timer () {
  { time { "${@:4}" ; } 2>${_} {_}>&- ; } {_}>&2 2>"/tmp/$$.$BASHPID.${#FUNCNAME[@]}"
  set -- $? "$@"
  read -d "" _ "$2" _ "$3" _ "$4" _ < "/tmp/$$.$BASHPID.${#FUNCNAME[@]}"
  rm -f "/tmp/$$.$BASHPID.${#FUNCNAME[@]}"
  return $1
}

p.ej

  timer r u s find /bin /sbin /usr rm /tmp/
  echo $r $u $s

y puede ser útil si termina siendo llamado de forma recursiva, para evitar pisotear a veces; pero luego rus, etc., deben declararse locales en su uso.

http://blog.sam.liddicott.com/2016/01/timeing-bash-commands.html