Alternativa universale non bash `time` benchmark? [chiuso]

Per confrontare i tempi di esecuzione degli script tra diverse shell, alcune risposte SE suggeriscono di usare bashil comando integrato, in questo time modo:

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

... ecc. , per ogni shell da testare. Tali parametri non riescono ad eliminare il tempo impiegato per ciascun guscio per caricare e inizializzare stessa . Ad esempio, supponiamo che entrambi i comandi di cui sopra siano stati memorizzati su un dispositivo lento con la velocità di lettura di un primo floppy disk , (124 KB / s), dash(un eseguibile di ~ 150 KB) caricerebbe circa 7 volte più veloce di bash( ~ 1 M ), la shell il tempo di caricamento distorcerebbe i timenumeri - i tempi di precaricamento di quelle shell sono irrilevanti per misurare i tempi di esecuzione di foo.shogni shell dopo che le shell sono state caricate.

Qual è la migliore utilità portatile e generale da eseguire per i tempi degli script che possono essere eseguiti all'interno di ogni shell? Quindi il codice sopra sarebbe simile a:

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

NB: nessun comando incorporato della shell time, poiché nessuno è portatile o generale.

Meglio ancora se l'utilità è anche in grado di confrontare il tempo impiegato dai comandi interni e dalle pipeline di una shell, senza che l'utente debba prima avvolgerli in uno script. Una sintassi artificiale come questa aiuterebbe:

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

Alcune shell ' timepossono gestirlo. Ad esempio bash -c "time while false ; do : ; done"funziona. Per vedere cosa funziona (e non funziona) sul tuo sistema prova:

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

Si noti che timeè specificato da POSIX e AFAICT l'unica opzione che POSIX menziona ( -p) è supportata correttamente da varie shell:

$ 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 il comando GNU date , che supporta un timer ad alta risoluzione:

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

"$@" &> /dev/null

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

E poi chiamo lo script in questo modo:

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

L'unità di output è in millisecondi.

L' timeutilità di solito è integrata nella shell, come hai notato, il che la rende inutile come timer "neutro".

Tuttavia, l'utilità è di solito disponibile anche come utilità esterna /usr/bin/time, che può essere utilizzata per eseguire gli esperimenti di temporizzazione proposti.

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

Ecco una soluzione che:

1. elimina [s] il tempo impiegato per il caricamento e l'inizializzazione di ciascuna shell

2. può essere eseguito da all'interno di ciascun guscio

3. usi

   nessun timecomando incorporato della shell , poiché nessuno è portatile o generale

4. Funziona con tutte le shell compatibili con POSIX.
5. Funziona su tutti i sistemi POSIX compatibili e conformi XSI con un compilatore C o in cui è possibile compilare un eseguibile C in anticipo.
6. Utilizza la stessa implementazione di temporizzazione su tutte le shell.

Ci sono due parti: un breve programma C che termina gettimeofday, che è deprecato ma ancora più portabile di quello clock_gettime, e uno script di shell corta che usa quel programma per ottenere un orologio di precisione in microsecondi che legge entrambi i lati del sourcing di uno script. Il programma C è l'unico modo portatile e minimale per ottenere una precisione di un secondo in un timestamp.

Ecco il programma 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);
}

E lo script della shell timer:

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

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

Questo è lo standard linguaggio di comando di shell e bce dovrebbe funzionare come uno script in qualsiasi shell compatibile POSIX.

Puoi usarlo come:

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

Non misura il tempo di sistema o dell'utente, ma solo il tempo trascorso non monotonico dell'orologio da parete. Se l'orologio di sistema cambia durante l'esecuzione dello script, ciò darà risultati errati. Se il sistema è sotto carico, il risultato non sarà affidabile. Non penso che qualcosa di meglio possa essere portatile tra le shell.

Uno script timer modificato potrebbe utilizzare evalinvece per eseguire comandi all'esterno di uno script.

Soluzione rivista più volte utilizzando /proc/uptimee dc/ bc/ awkin grandi parti grazie all'input di 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."

Suppone ovviamente che /proc/uptimeesista e abbia una certa forma.