Alternative de référence universelle non-bash `time '? [fermé]

Pour comparer les temps d'exécution des scripts entre différents shells, certaines réponses SE suggèrent d'utiliser bashla commande intégrée de time , comme ceci:

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

... etc , pour chaque shell à tester. Ces critères de référence ne parviennent pas à éliminer le temps nécessaire pour chaque coquille charger et initialiser lui - même . Par exemple, supposons que les deux commandes ci-dessus aient été stockées sur un périphérique lent avec la vitesse de lecture d'une disquette ancienne , (124 Ko / s), dash(un exécutable de ~ 150 Ko) se chargerait environ 7 fois plus rapidement que bash( ~ 1 M ), le shell le temps de chargement fausserait les timechiffres - les temps de préchargement de ces réservoirs étant sans rapport avec la mesure des durées de fonctionnement de foo.shchaque coquille après le chargement des réservoirs.

Quelle est la meilleure utilisation portable et générale à exécuter pour la synchronisation des scripts qui peut être exécutée à partir de chaque shell? Ainsi, le code ci-dessus ressemblerait à quelque chose comme:

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

NB: pas de time commandes intégrées au shell , car aucune n'est portable ou générale.

Mieux encore si l'utilitaire est également capable de comparer le temps pris par les commandes internes et les pipelines d'un shell, sans que l'utilisateur n'ait à les emballer au préalable dans un script. Une syntaxe artificielle comme celle-ci aiderait:

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

Certains obus timepeuvent gérer cela. Par exemple bash -c "time while false ; do : ; done"fonctionne. Pour voir ce qui fonctionne (et ne fonctionne pas) sur votre système, essayez:

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

Vous devriez noter que timec'est spécifié par POSIX , et AFAICT la seule option que POSIX mentionne ( -p) est prise en charge correctement par divers 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

J'utilise la commande GNU date , qui prend en charge une minuterie haute résolution:

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

"$@" &> /dev/null

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

Et puis j'appelle le script comme ceci:

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

L'unité de sortie est en millisecondes.

L' timeutilitaire est généralement intégré au shell, comme vous l'avez remarqué, ce qui le rend inutile en tant que temporisateur "neutre".

Cependant, l'utilitaire est généralement également disponible en tant qu'utilitaire externe /usr/bin/time, qui peut très bien être utilisé pour effectuer les expériences de synchronisation que vous proposez.

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

Voici une solution qui:

1. éliminer [s] le temps nécessaire à chaque shell pour se charger et s'initialiser

2. peut être exécuté à partir de chaque shell

3. Les usages

   pas de timecommandes intégrées au shell , car aucune n'est portable ou générale

4. Fonctionne dans tous les shells compatibles POSIX.
5. Fonctionne sur tous les systèmes compatibles POSIX et conformes à XSI avec un compilateur C , ou où vous pouvez compiler un exécutable C à l'avance.
6. Utilise la même implémentation de synchronisation sur tous les shells.

Il y a deux parties: un programme C court qui se termine gettimeofday, qui est obsolète mais toujours plus portable que clock_gettime, et un script shell court qui utilise ce programme pour obtenir une horloge de précision en microsecondes lisant les deux côtés de l'approvisionnement d'un script. Le programme C est le seul moyen portable et à surcharge minimale pour obtenir une précision d'une sous-seconde sur un horodatage.

Voici le programme 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);
}

Et le script shell timer:

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

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

Ce standard langage de commande shell et bcet devrait fonctionner comme un script shell sous tout compatible POSIX.

Vous pouvez l'utiliser comme:

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

Il ne mesure pas le temps système ou utilisateur, seulement le temps écoulé d'horloge murale non monotone. Si l'horloge système change pendant l'exécution du script, cela donnera des résultats incorrects. Si le système est sous charge, le résultat ne sera pas fiable. Je ne pense pas que quelque chose de mieux puisse être portable entre les coquilles.

Un script de minuterie modifié pourrait utiliser à la evalplace pour exécuter des commandes en dehors d'un script.

Solution révisée à plusieurs reprises utilisant /proc/uptimeet dc/ bc/ awken grande partie grâce à l'entrée par 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."

Suppose évidemment que cela /proc/uptimeexiste et a une certaine forme.