Alternativa universal de referência não-bash `time`? [fechadas]

Para comparar tempos de execução de scripts de entre diferentes conchas, algumas respostas SE sugerir o uso bashde alto- time comando, assim:

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

... etc , para cada shell testar. Esses benchmarks falham em eliminar o tempo necessário para cada shell carregar e inicializar a si próprio . Por exemplo, suponha que ambos os comandos acima foram armazenados em um dispositivo lento com a velocidade de leitura de um disquete inicial (124KB / s), dash(um executável de ~ 150K ) carregaria cerca de 7x mais rápido que bash( ~ 1M ), o shell o tempo de carregamento distorceria os timenúmeros - os tempos de pré-carregamento dessas conchas eram irrelevantes para medir os tempos de execução foo.shsob cada concha após o carregamento das conchas.

Qual é a melhor util portátil e geral para correr para o sincronismo script que pode ser executado a partir de dentro de cada shell? Portanto, o código acima seria algo como:

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

NB: no shell built-in time comandos, uma vez que nenhum são portáteis ou geral.

Melhor ainda, se o utilitário também puder avaliar o tempo gasto pelos comandos e pipelines internos de um shell, sem que o usuário precise primeiro envolvê-los em um script. Sintaxe artificial como esta ajudaria:

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

Algumas conchas timepodem gerenciar isso. Por exemplo bash -c "time while false ; do : ; done"funciona. Para ver o que funciona (e não funciona) no seu sistema, tente:

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

Você deve observar que timeé especificado pelo POSIX e AFAICT, a única opção mencionada pelo POSIX ( -p) é suportada corretamente por vários 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

Eu uso o comando GNU date , que suporta um timer de alta resolução:

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

"$@" &> /dev/null

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

E então eu chamo o script assim:

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

A unidade de saída está em milissegundos.

O timeutilitário geralmente é incorporado ao shell, como você notou, o que o torna inútil como um temporizador "neutro".

No entanto, o utilitário geralmente também está disponível como um utilitário externo /usr/bin/time, que pode muito bem ser usado para executar as experiências de tempo que você propõe.

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

Aqui está uma solução que:

1. elimina [s] o tempo necessário para cada shell carregar e inicializar a si próprio

2. pode ser executado dentro de cada shell

3. Usos

   sem comandos internos do shell time, pois nenhum é portátil ou geral

4. Funciona em todos os shells compatíveis com POSIX.
5. Funciona em todos os sistemas compatíveis com POSIX e XSI com um compilador C , ou onde você pode compilar um executável C com antecedência.
6. Usa a mesma implementação de tempo em todos os shells.

Há duas partes: um pequeno programa C que termina gettimeofday, que é preterido, mas ainda mais portátil que um clock_gettime, e um pequeno script de shell que usa esse programa para obter um relógio de microssegundo lendo os dois lados da fonte de um script. O programa C é a única maneira portátil e com sobrecarga mínima para obter uma precisão de menos de um segundo em um registro de data e hora.

Aqui está o 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);
}

E o script de shell timer:

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

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

Este é o padrão linguagem de comandos shell e bce deve funcionar como um script em qualquer shell compatível com POSIX.

Você pode usar isso como:

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

Ele não mede o tempo do sistema ou do usuário, apenas o tempo decorrido do relógio de parede não monotônico. Se o relógio do sistema mudar durante a execução do script, isso fornecerá resultados incorretos. Se o sistema estiver sob carga, o resultado não será confiável. Eu não acho que nada melhor possa ser portátil entre conchas.

Um script de timer modificado pode ser usado evalpara executar comandos fora de um script.

Solução revisada várias vezes usando /proc/uptimee dc/ bc/ awkem grandes partes, graças à entrada da 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."

Supõe obviamente que /proc/uptimeexiste e tem uma determinada forma.