Czy uniwersalna alternatywa porównawcza dla „czasu”? [Zamknięte]

Dla porównania prowadzone razy skryptów między różnymi muszli, niektóre odpowiedzi SE sugerować przy użyciu bash„s wbudowane time polecenia, tak jak poniżej:

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

... itd. dla każdej powłoki do przetestowania. Takie odniesienia nie eliminuje czas potrzebny dla każdej muszli załadować i zainicjować sama . Załóżmy na przykład, że oba powyższe polecenia zostały zapisane na wolnym urządzeniu z prędkością odczytu wczesnej dyskietki (124KB / s) dash( plik wykonywalny ~ 150K ) ładowałby się około 7 razy szybciej niż bash( ~ 1M ) powłoka czas ładowania będzie pochylać się timenumery - czasów pre-loading tych pocisków nie ma znaczenia do pomiaru czasów pracy foo.shpod każdym skorupy po pociski zostały załadowane.

Jakie jest najlepsze przenośne i ogólne zastosowanie do uruchamiania taktowania skryptów, które można uruchomić z poziomu każdej powłoki? Tak więc powyższy kod wyglądałby mniej więcej tak:

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

Uwaga: brak wbudowanych time poleceń powłoki , ponieważ żadne nie są przenośne ani ogólne.

Jeszcze lepiej, jeśli util jest również w stanie przeprowadzić analizę porównawczą czasu potrzebnego na wewnętrzne polecenia i potoki powłoki, bez konieczności uprzedniego zawijania ich przez skrypt w skrypcie. Sztuczna składnia taka jak ta pomogłaby:

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

Niektóre powłoki timemogą sobie z tym poradzić. Na przykład bash -c "time while false ; do : ; done"działa. Aby zobaczyć, co działa (i nie działa) w twoim systemie, spróbuj:

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

Należy zauważyć, że timejest to określone przez POSIX , a AFAICT jedyna opcja, o której POSIX wspomina ( -p) jest poprawnie obsługiwana przez różne powłoki:

$ 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

Używam polecenia GNU date , które obsługuje zegar wysokiej rozdzielczości:

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

"$@" &> /dev/null

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

A potem wywołuję skrypt w następujący sposób:

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

Jednostka wyjściowa jest w milisekundach.

timeNarzędzie jest zwykle wbudowany w skorupkach, jak zauważyłeś, co czyni go bezużytecznym jako „neutralny” timer.

Jednak narzędzie jest zwykle dostępne również jako narzędzie zewnętrzne /usr/bin/time, które może być również wykorzystane do przeprowadzenia proponowanych eksperymentów czasowych.

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

Oto rozwiązanie, które:

1. wyeliminuj czas potrzebny na załadowanie się i zainicjowanie każdej powłoki

2. można uruchamiać od wewnątrz każdej skorupy

3. Używa

   brak wbudowanych timepoleceń powłoki , ponieważ żadne nie są przenośne ani ogólne

4. Działa we wszystkich powłokach zgodnych z POSIX.
5. Działa na wszystkich systemach zgodnych z POSIX i zgodnych z XSI z kompilatorem C lub tam, gdzie można wcześniej skompilować plik wykonywalny C.
6. Używa tej samej implementacji czasowej we wszystkich powłokach.

Składa się z dwóch części: krótkiego programu C, który się kończy gettimeofday, który jest przestarzały, ale wciąż bardziej przenośny niż clock_gettimei krótkiego skryptu powłoki, który używa tego programu, aby uzyskać zegar o precyzji mikrosekundowej odczytujący obie strony pozyskiwania skryptu. Program C jest jedynym przenośnym i minimalnym narzutem sposobem uzyskania precyzji poniżej sekundy na znaczniku czasu.

Oto program 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);
}

I skrypt powłoki timer:

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

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

Jest to standardowy język poleceń powłoki i bcpowinny działać jako skrypt pod dowolnym kompatybilnym z POSIX powłoki.

Możesz użyć tego jako:

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

Nie mierzy czasu systemowego ani użytkownika, a jedynie upływ czasu niemonotonicznego zegara ściennego. Jeśli zegar systemowy zmieni się podczas wykonywania skryptu, da to nieprawidłowe wyniki. Jeśli system jest obciążony, wynik będzie niewiarygodny. Nie sądzę, żeby coś lepszego można było przenosić między pociskami.

evalZamiast tego można użyć skryptu timera do uruchamiania poleceń poza skryptem.

Wielokrotnie poprawione rozwiązanie wykorzystujące /proc/uptimei dc/ bc/ awkw dużych częściach dzięki wprowadzeniu przez 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."

Zakłada oczywiście, że /proc/uptimeistnieje i ma pewną formę.