Universelle Non-Bash-Zeit-Benchmark-Alternative? [geschlossen]

Für den Vergleich der Laufzeiten von Skripten zwischen verschiedenen Shells empfehlen einige SE-Antworten die Verwendung bash des integrierten time Befehls wie folgt:

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

... usw. , damit jede Shell getestet werden kann. Solche Benchmarks eliminieren nicht die Zeit, die jede Shell benötigt, um sich selbst zu laden und zu initialisieren . Angenommen, beide oben genannten Befehle wurden auf einem langsamen Gerät mit der Lesegeschwindigkeit einer frühen Diskette gespeichert (124 KB / s) dash(eine ausführbare Datei mit ~ 150 KB), die etwa 7x schneller als die Shell bash( ~ 1 MB ) geladen würde Die Ladezeit würde die timeZahlen verzerren - die Vorladezeiten dieser Schalen sind für die Messung der Laufzeiten foo.shunter jeder Schale nach dem Laden der Schalen irrelevant .

Was ist das beste tragbare und allgemeine Dienstprogramm für das Skript-Timing, das in jeder Shell ausgeführt werden kann? Der obige Code würde also ungefähr so ​​aussehen:

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

NB: keine Shell integrierten time Befehle, da keine portabel oder allgemein sind.

Besser noch, wenn der Util auch die Zeit messen kann, die die internen Befehle und Pipelines einer Shell benötigen, ohne dass der Benutzer sie zuerst in ein Skript einbinden muss. Eine künstliche Syntax wie diese würde helfen:

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

Einige Muscheln timekönnen das schaffen. Zum Beispiel bash -c "time while false ; do : ; done"funktioniert. Um zu sehen, was auf Ihrem System funktioniert (und was nicht), versuchen Sie Folgendes:

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

Sie sollten beachten, dass dies timevon POSIX angegeben wird und AFAICT die einzige Option, die POSIX erwähnt ( -p), von verschiedenen Shells korrekt unterstützt wird:

$ 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

Ich benutze den GNU- date Befehl, der einen hochauflösenden Timer unterstützt:

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

"$@" &> /dev/null

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

Und dann nenne ich das Skript so:

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

Die Ausgabeeinheit ist in Millisekunden angegeben.

Das time Dienstprogramm ist in der Regel in die Schale eingebaut, wie Sie vielleicht bemerkt haben, die es nutzlos als „neutral“ Timer macht.

Das Dienstprogramm ist jedoch normalerweise auch als externes Dienstprogramm verfügbar /usr/bin/time, das durchaus zur Durchführung der von Ihnen vorgeschlagenen Timing-Experimente verwendet werden kann.

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

Hier ist eine Lösung, die:

1. Eliminieren Sie [s] die Zeit, die jede Shell benötigt, um sich selbst zu laden und zu initialisieren

2. kann von innen ausgeführt werden jeder Schale

3. Verwendet

   Keine in die Shell integrierten timeBefehle, da keine portabel oder allgemein sind

4. Funktioniert in allen POSIX-kompatiblen Shells.
5. Funktioniert auf allen POSIX-kompatiblen und XSI-konformen Systemen mit einem C-Compiler oder wenn Sie eine ausführbare C-Datei im Voraus kompilieren können.
6. Verwendet für alle Shells dieselbe Timing-Implementierung.

Es gibt zwei Teile: ein kurzes C-Programm, das abgeschlossen wird gettimeofday , das veraltet, aber immer noch portabler als ist clock_gettime, und ein kurzes Shell-Skript, das dieses Programm verwendet, um eine Uhr mit Mikrosekundengenauigkeit zu erhalten, die beide Seiten der Beschaffung eines Skripts liest. Das C-Programm ist die einzige tragbare Methode mit minimalem Overhead, um eine Genauigkeit von weniger als einer Sekunde für einen Zeitstempel zu erzielen.

Hier ist das C-Programm 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);
}

Und das Shell-Skript timer:

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

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

Dies ist die Standard- Shell-Befehlssprache undbc und soll als Skript unter jedem POSIX-kompatiblen Shell arbeiten.

Sie können dies verwenden als:

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

Es misst nicht die System- oder Benutzerzeit, sondern nur die nicht monotone Wanduhr. Wenn sich die Systemuhr während der Ausführung des Skripts ändert, führt dies zu falschen Ergebnissen. Wenn das System unter Last steht, ist das Ergebnis unzuverlässig. Ich denke nicht, dass etwas Besseres zwischen Muscheln tragbar sein kann.

Ein modifiziertes Timer-Skript könnte evalstattdessen Befehle außerhalb eines Skripts ausführen.

Mehrfach überarbeitete Lösung mit /proc/uptimeund dc/ bc/ awkin großen Teilen dank der Eingabe von 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."

Nimmt offensichtlich an, dass es /proc/uptimeexistiert und eine bestimmte Form hat.