¿Alternativa de referencia de tiempo universal no bash? [cerrado]

Para comparar los tiempos de ejecución de los scripts entre diferentes shells, algunas respuestas de SE sugieren usar bashel comando incorporado de la siguiente time manera:

time bash -c 'foo.sh'
time dash -c 'foo.sh'

... etc , para cada shell para probar. Tales puntos de referencia no logran eliminar el tiempo tomado para cada shell para cargar e inicializar sí . Por ejemplo, suponga que los dos comandos anteriores se almacenaron en un dispositivo lento con la velocidad de lectura de un disquete anterior , (124KB / s), dash(un ejecutable de ~ 150K ) se cargaría aproximadamente 7 veces más rápido que bash( ~ 1M ), el shell el tiempo de carga sesgaría los timenúmeros: los tiempos de precarga de esos proyectiles son irrelevantes para medir los tiempos de ejecución foo.shdebajo de cada proyectil después de cargar los proyectiles.

Cuál es la mejor util portátil y en general a una duración de tiempo de la escritura que se pueden ejecutar desde dentro de cada capa? Entonces, el código anterior se vería así:

bash -c 'general_timer_util foo.sh'
dash -c 'general_timer_util foo.sh'

NB: no hay comandos integrados de shell time, ya que ninguno es portátil o general.

Mejor aún si la utilidad también es capaz de comparar el tiempo que tardan los comandos internos y las canalizaciones de un shell, sin que el usuario tenga que envolverlos primero en un script. La sintaxis artificial como esta ayudaría:

general_timer_util "while read x ; do echo x ; done < foo"

Algunos proyectiles timepueden manejar esto. Por ejemplo bash -c "time while false ; do : ; done"funciona. Para ver qué funciona (y qué no) en su sistema, intente:

tail +2 /etc/shells | 
while read s ; do 
    echo $s ; $s -c "time while false ; do : ; done" ; echo ----
done

Debe tener en cuenta que timePOSIX lo especifica , y AFAICT es la única opción que POSIX menciona ( -p) es compatible con varios shells:

$ bash -c 'time -p echo'

real 0.00
user 0.00
sys 0.00
$ dash -c 'time -p echo'

real 0.01
user 0.00
sys 0.00
$ busybox sh -c 'time -p echo'

real 0.00
user 0.00
sys 0.00
$ ksh -c 'time -p echo'       

real 0.00
user 0.00
sys 0.00

Uso el comando GNU date , que admite un temporizador de alta resolución:

START=$(date +%s.%N)
# do something #######################

"$@" &> /dev/null

#######################################
END=$(date +%s.%N)
DIFF=$( echo "scale=3; (${END} - ${START})*1000/1" | bc )
echo "${DIFF}"

Y luego llamo al guión así:

/usr/local/bin/timing dig +short unix.stackexchange.com
141.835

La unidad de salida está en milisegundos.

La timeutilidad generalmente está integrada en el shell, como se habrá dado cuenta, lo que la hace inútil como un temporizador "neutral".

Sin embargo, la utilidad generalmente también está disponible como una utilidad externa /usr/bin/time, que bien puede usarse para realizar los experimentos de temporización que usted propone.

$ bash -c '/usr/bin/time foo.sh'

Aquí hay una solución que:

1. eliminar [s] el tiempo que tarda cada shell en cargarse e inicializarse

2. se puede ejecutar desde dentro de cada cáscara

3. Usos

   no hay comandos integrados de shell time, ya que ninguno es portátil o general

4. Funciona en todos los shells compatibles con POSIX.
5. Funciona en todos los sistemas compatibles con POSIX y XSI con un compilador de C , o donde puede compilar un ejecutable de C por adelantado.
6. Utiliza la misma implementación de temporización en todos los shells.

Hay dos partes: un programa C corto que finaliza gettimeofday, que está en desuso pero aún más portátil que clock_gettime, y un script de shell corto que usa ese programa para obtener un reloj de precisión de microsegundos que lee ambos lados de la fuente de un script. El programa C es la única forma portátil y mínima para obtener una precisión de menos de un segundo en una marca de tiempo.

Aquí está el programa C epoch.c:

#include <sys/time.h>
#include <stdio.h>
int main(int argc, char **argv) {
    struct timeval time;
    gettimeofday(&time, NULL);
    printf("%li.%06i", time.tv_sec, time.tv_usec);
}

Y el script de shell timer:

#!/bin/echo Run this in the shell you want to test

START=$(./epoch)
. "$1"
END=$(./epoch)
echo "$END - $START" | bc

Esta es la norma lenguaje de comandos shell y bcy debería funcionar como un guión bajo cualquier shell compatible con POSIX.

Puedes usar esto como:

$ bash timer ./test.sh
.002052
$ dash timer ./test.sh
.000895
$ zsh timer ./test.sh
.000662

No mide el tiempo del sistema o del usuario, solo el tiempo transcurrido del reloj de pared no monótono. Si el reloj del sistema cambia durante la ejecución del script, esto dará resultados incorrectos. Si el sistema está bajo carga, el resultado será poco confiable. No creo que nada mejor pueda ser portátil entre proyectiles.

Un script de temporizador modificado podría usarse evalen su lugar para ejecutar comandos fuera de un script.

Solución revisada varias veces usando /proc/uptimey dc/ bc/ awken partes grandes gracias a la entrada de agc :

#!/bin/sh

read -r before _ < /proc/uptime

sleep 2s # do something...

read -r after _ < /proc/uptime

duration=$(dc -e "${after} ${before} - n")
# Alternative using bc:
#   duration=$(echo "${after} - ${before}" | bc)
# Alternative using awk:
#   duration=$(echo "${after} ${before}" | awk '{print $1 - $2}')

echo "It took $duration seconds."

Asume obviamente que /proc/uptimeexiste y tiene una cierta forma.