Ottieni il tempo di esecuzione del programma nella shell

Voglio eseguire qualcosa in una shell linux in alcune condizioni diverse ed essere in grado di generare il tempo di esecuzione di ogni esecuzione.

So che potrei scrivere uno script perl o python che lo farebbe, ma c'è un modo per farlo nella shell? (che sembra essere bash)

Usa la timeparola chiave integrata :

$ tempo di aiuto

time: time [-p] PIPELINE
    Eseguire PIPELINE e stampare un riepilogo del tempo reale, del tempo della CPU dell'utente,
    e il tempo della CPU di sistema impiegato per l'esecuzione di PIPELINE al termine.
    Lo stato di ritorno è lo stato di ritorno di PIPELINE. L'opzione `-p '
    stampa il riepilogo dei tempi in un formato leggermente diverso. Questo usa
    il valore della variabile TIMEFORMAT come formato di output.

Esempio:

$ time sleep 2

0m2.009 reali
utente 0m0.000s
sys 0m0.004s

Puoi ottenere informazioni molto più dettagliate rispetto al bash integrato time(che Robert Gamble menziona) usando time (1) . Normalmente questo è /usr/bin/time.

^{Nota del redattore: per assicurarti di invocare l' utilità esterna time anziché la time parola chiave della shell , invocala come /usr/bin/time.
timeè un'utilità POSIX , ma l'unica opzione che è richiesta per supportare è -p.
Piattaforme specifiche implementano estensioni specifiche non standard: -vfunzionano con l' utilità GNUtime , come dimostrato di seguito (la domanda è taggatalinux); l'implementazione di BSD / macOS utilizza -lper produrre un output simile - vedi man 1 time.}

Esempio di output dettagliato:

$ /usr/bin/time -v sleep 1
       Command being timed: "sleep 1"
       User time (seconds): 0.00
       System time (seconds): 0.00
       Percent of CPU this job got: 1%
       Elapsed (wall clock) time (h:mm:ss or m:ss): 0:01.05
       Average shared text size (kbytes): 0
       Average unshared data size (kbytes): 0
       Average stack size (kbytes): 0
       Average total size (kbytes): 0
       Maximum resident set size (kbytes): 0
       Average resident set size (kbytes): 0
       Major (requiring I/O) page faults: 0
       Minor (reclaiming a frame) page faults: 210
       Voluntary context switches: 2
       Involuntary context switches: 1
       Swaps: 0
       File system inputs: 0
       File system outputs: 0
       Socket messages sent: 0
       Socket messages received: 0
       Signals delivered: 0
       Page size (bytes): 4096
       Exit status: 0

#!/bin/bash
START=$(date +%s)
# do something
# start your script work here
ls -R /etc > /tmp/x
rm -f /tmp/x
# your logic ends here
END=$(date +%s)
DIFF=$(( $END - $START ))
echo "It took $DIFF seconds"

Per una misurazione delta riga per riga, prova gnomon .

Un'utilità della riga di comando, un po 'come ts di moreutils, per anteporre le informazioni di data e ora all'output standard di un altro comando. Utile per i processi di lunga durata in cui desideri un record storico di ciò che richiede così tanto tempo.

Puoi anche usare le opzioni --highe / o --mediumper specificare una soglia di lunghezza in secondi, su cui gnomon evidenzierà il timestamp in rosso o giallo. E puoi fare anche poche altre cose.

Se vuoi maggiore precisione, usa %Ncon date(e usa bcper il diff, perché $(())gestisce solo numeri interi).

Ecco come farlo:

start=$(date +%s.%N)
# do some stuff here
dur=$(echo "$(date +%s.%N) - $start" | bc)

printf "Execution time: %.6f seconds" $dur

Esempio:

start=$(date +%s.%N); \
  sleep 0.1s; \
  dur=$(echo "$(date +%s.%N) - $start" | bc); \
  printf "Execution time: %.6f seconds\n" $dur

Risultato:

Execution time: 0.104623 seconds

Se hai intenzione di utilizzare i tempi in seguito per calcolare, scopri come utilizzare l' -fopzione di /usr/bin/timeoutput del codice che salva i tempi. Ecco un po 'di codice che ho usato di recente per ottenere e ordinare i tempi di esecuzione di un'intera classe di programmi per studenti:

fmt="run { date = '$(date)', user = '$who', test = '$test', host = '$(hostname)', times = { user = %U, system = %S, elapsed = %e } }"
/usr/bin/time -f "$fmt" -o $timefile command args...

Successivamente ho concatenato tutti i $timefilefile e convogliato l'output in un interprete Lua . Puoi fare lo stesso con Python o bash o qualunque sia la tua sintassi preferita. Adoro questa tecnica.

Se hai solo bisogno di precisione al secondo, puoi usare la $SECONDSvariabile built-in , che conta il numero di secondi in cui la shell è stata in esecuzione.

while true; do
    start=$SECONDS
    some_long_running_command
    duration=$(( SECONDS - start ))
    echo "This run took $duration seconds"
    if some_condition; then break; fi
done

È possibile utilizzare timee subshell () :

time (
  for (( i=1; i<10000; i++ )); do
    echo 1 >/dev/null
  done
)

O nella stessa shell {}:

time {
  for (( i=1; i<10000; i++ )); do
    echo 1 >/dev/null
  done
}

Il modo è

$ > g++ -lpthread perform.c -o per
$ > time ./per

l'output è >>

real    0m0.014s
user    0m0.010s
sys     0m0.002s

un metodo possibilmente semplice (che potrebbe non soddisfare le diverse esigenze degli utenti) è l'uso della shell PROMPT.it è una soluzione semplice che può essere utile in alcuni casi. È possibile utilizzare la funzione di prompt di bash come nell'esempio seguente:

export PS1 = '[\ t \ u @ \ h] \ $' 

Il comando precedente comporterà la modifica del prompt della shell in:

[HH: MM: nome utente SS @ nome host] $ 

Ogni volta che si esegue un comando (o si preme invio) tornando al prompt della shell, il prompt visualizzerà l'ora corrente.

note:
1) attenzione che se si è aspettato qualche tempo prima di digitare il comando successivo, è necessario considerare questa volta, ovvero l'ora visualizzata nel prompt della shell è il timestamp quando è stato visualizzato il prompt della shell, non quando si immette il comando. alcuni utenti scelgono di premere il tasto Invio per ottenere un nuovo prompt con un nuovo timestamp prima di essere pronti per il comando successivo.
2) Ci sono altre opzioni e modificatori disponibili che possono essere usati per cambiare il prompt di bash, fare riferimento a (man bash) per maggiori dettagli.