Se tudo que você quer é tempo decorrido, então com zsh ou ksh93:
$ typeset -F SECONDS=0; sleep 1; print "$SECONDS"
1.0012850761
Agora, se esse tipo de precisão faz sentido é outra questão.
Estou tentando obter o tempo que meu programa leva para terminar (também conhecido como tempo decorrido), então estou usando o time comum.
O que eu ganho fazendo isso é 3 medições: usuário, sistema e total. Isso é bom, mas descobri que a hora do usuário em que estou interessado tem apenas duas casas decimais e eu precisaria de mais. Existe alguma maneira de obter mais casas decimais do meu comando de tempo?
Exemplo: time ./myCProgram
Saída: 0,17s usuário 1,21s sistema 130% cpu 0,187 total
Desejo desejado: 0.17000s usuário sistema 1.21s 130% cpu 0.187 no total (ou mais casas decimais)
GNU/Linux , usando bash . AVISO Este post foi tornado obsoleto por um novo método interessante discutido aqui: Profiling bash (3 respostas) e com completo pronto para uso arquivo fonte lá: Elap-bash V3
Há alguma maneira de pedir tempo em uma granularidade mais fina que um segundo.
Por 1/100 de segundo, você pode simplesmente consultar /proc/uptime :
sed 's/ .*$//' /proc/uptime
276440.58
O desvio de tempo para adicionar para o cálculo do tempo UTC real pode ser obtido por um dos seguintes:
ps ho lstart 1 | date -f - +%s
1357193821
ou
date +%s.%N-$(sed 's/ .*$//' /proc/uptime ) | bc -l
1357193821.088187101
Como o offset é estático, esse valor pode ser calculado apenas 1 vez, no início do script.
proc entradas: Para computação com nanossegundos , há um proc entry , denominado /proc/timer_list , que contém uptime e offset :
sed < /proc/timer_list -ne '/now at/p;/offset/{p;q}'
now at 276350507668586 nsecs
.offset: 1357193821075753443 nsecs
Então isso
echo $(($(sed < /proc/timer_list -ne '
/^now at/{s/now at \([0-9]*\) ns.*$//;H};
/offset/{s/^.*: *\([0-9]*\) ns.*$//;G;s/\n\+/+/;p;q}')))
1357470173543424035
é o número inteiro de nanossegundos decorridos em 1970-1-1 00:00:00 UTC .
Para números inteiros em bash , não é necessário usar bc e para analisar arquivos proc, podemos usar mapfile , que é um bash builtin :
# first, some static variables (with fork, but only 1 time, at begin;):
nowAtLine=$(($(sed -ne < /proc/timer_list '/now at/{=;q}')-1))
offset=$(sed -ne < /proc/timer_list '
/offset/{s/^.*: *\([0-9]*\) n.*$//p;q}')
# than this will be a lot quicker than a fork:
mapfile -n 1 -s $nowAtLine timerList </proc/timer_list &&
timerList=($timerList) &&
echo $((${timerList[2]}+offset))
1357470173543424035
date binary: E, se não existirem, poderíamos ligar para date , lembrando que é um fork que demora muito mais tempo do que ler proc files , permanecendo em apenas uma sessão bash.
date +%s%N
1357470074808968375
elap.bash com base nisso, eu escrevi uma função elap bash , com dois contadores: 1 para cada chamada e outro para uma espécie de overall duration .
Primeiro, esta é uma função , não um script . Você tem que source deles em sua sessão bash atual para usá-lo.
. elap.bash
elap [ [ -r | -R ] | [ -n ] [ -t | -T ] [<simple text report>] ]
-r reset first counter only, don't output anything, like -R...
-R reset both counters, (both -r and -R must by unique argument)
-n don't reset any counter (just print)
-t print both counters (reset first counter)
-T print and reset
Para redefinir os dois contadores antes de usá-lo:
elap -R
find /usr/bin >/dev/null
elap browsing /usr/bin
0.025389543 browsing /usr/bin
Você pode adicionar alguns marcadores em um script:
#!/bin/bash
. elap.bash
elap -R
tar -cf /tmp/test.tar -C / bin
elap making a tarball of $(stat -c %s /tmp/test.tar) bytes
gzip /tmp/test.tar
elap compressing them to $(stat -c %s /tmp/test.tar.gz) bytes
scp /tmp/test.tar.gz [email protected]:backups/
elap sending file to backup server
rm /tmp/test.tar.gz
elap removing compressed tarball
elap -t total duration
0.043223957 making a tarball of 5877760 bytes
0.667249628 compressing them to 2742537 bytes
test.tar.gz 100% 2678KB 2.6MB/s 00:00
0.380779818 sending file to backup server
0.010262259 removing compressed tarball
0.003566335 1.105081997 total duration
trap debug para seguir passo a passo
Com ou sem a opção -t , usando trap debug para o passo a passo, com menos alteração de script (adicionadas quatro linhas na parte superior do script e uma na parte inferior):
Como o trapping para debug ocorrerá antes de $BASH_COMMAND execution, precisamos armazenar conteúdo variável em uma variável $BASH_LAST para a impressão correta e adicionar um > dummy comando na parte inferior do script.
#!/bin/bash
. elap.bash
elap -R
export BASH_LAST=Starting
trap 'elap -t $BASH_LAST;BASH_LAST=$BASH_COMMAND' debug
tar -cf /tmp/test.tar -C / bin
gzip /tmp/test.tar
scp /tmp/test.tar.gz [email protected]:backups/
rm /tmp/test.tar.gz
exit $?
O comando exit $? é necessário para despejar statistiques após o último comando rm .
0.001011086 0.001011086 Starting
0.045175969 0.046187055 tar -cf /tmp/test.tar -C / bin
0.651394209 0.697581264 gzip /tmp/test.tar
test.tar.gz 100% 2678KB 2.6MB/s 00:00
0.374499354 1.072080618 scp /tmp/test.tar.gz [email protected]:backups/
0.007160101 1.079240719 rm /tmp/test.tar.gz
Onde você pode cortar (ou reordenar) uptime part, se preferir usar garfo para date +%s%N em vez de usar granularidade de 1/100 de segundo.
#
# Bash source file for fine elapsed time reporting
# based on /proc/timer_list, display elapsed time in nanosecs
# or /proc/uptime if timer_list not present, for 100th of secs.
# if none of them if present, fall back to *fork* 'date +%s%N'.
#
# (C) 2011-2012 Felix Hauri - [email protected]
# Licensed under terms of LGPL v3. www.gnu.org
# Usage:
# load script into bash using ''source elap.bash''
#
# Syntaxe: elap [ [ -r | -R ] | [ -n ] [ -t | -T ] [<simple text report>] ]
# -r reset first counter only, don't output anything, like -R...
# -R reset both counters, (both -r and -R must by unique argument)
# -n don't reset any counter (just print)
# -t print both counters (reset first counter)
# -T print and reset
#
# nota: using ''-n'' in combinaison with any of ''-r'' or ''-R'' is buggy.
export _elaP_now _elaP_last _elaP_elap _elaP_last2 _elaP_dec
if [ -r /proc/timer_list ] ;then
_elaP_file=/proc/timer_list
_elaP_dec=9
_elaP_field=2
mapfile < $_elaP_file _elaP_now
_elaP_line=0
while [ "${_elaP_now[_elaP_line]}" == \
"${_elaP_now[_elaP_line]#*now at}" ] ;do
((_elaP_line++))
done
eval 'function elap_getNow() {
mapfile -n 1 -s '$_elaP_line' <'$_elaP_file' _elaP_now
_elaP_now=($_elaP_now)
_elaP_now=${_elaP_now[_elaP_field]}
}'
else
# --- To be removed for nanoseconds only
if [ -r /proc/uptime ] ;then
_elaP_dec=2
function elap_getNow() {
read -a _elaP_now </proc/uptime _elaP_now
_elaP_now=${_elaP_now//./}
}
else # --- End of part to be removed for ns only.
_elaP_dec=9
function elap_getNow() { _elaP_now=$(date +%s%N) ;}
fi # --- Remove this line too for ns only.
fi
export -f elap_getNow
elap() {
local _Z9=000000000
local _elaP_setLast=true
[ "$1" == "-n" ] && shift && _elaP_setLast=false
[ "$2" == "-n" ] && set -- $1 ${@:3} && _elaP_setLast=false
elap_getNow
_elaP_elap=$((_elaP_now - _elaP_last))
[ ${#_elaP_elap} -lt $_elaP_dec ] && \
_elaP_elap=${_Z9:0:_elaP_dec-${#_elaP_elap}}$_elaP_elap
[ "${*}" == "-R" ] && _elaP_last2=$_elaP_now || \
[ "${*}" == "-r" ] || if [ "$1" == "-t" ] || [ "$1" == "-T" ] ;then
local _elaP_setLast2=false
[ "$1" == "-T" ] && _elaP_setLast2=true
shift
_elaP_elap2=$((_elaP_now - _elaP_last2))
[ ${#_elaP_elap2} -lt $_elaP_dec ] && \
_elaP_elap2="${_Z9:0:_elaP_dec-${#_elaP_elap2}}$_elaP_elap2"
printf "%6d.%s %6d.%s %s\n" \
"${_elaP_elap:0:${#_elaP_elap}-$_elaP_dec}" \
"${_elaP_elap:${#_elaP_elap}-_elaP_dec}" \
"${_elaP_elap2:0:${#_elaP_elap2}-$_elaP_dec}" \
"${_elaP_elap2:${#_elaP_elap2}-_elaP_dec}" "${*}"
$_elaP_setLast2 && _elaP_last2=$_elaP_now
else
printf "%6d.%s %s\n" \
"${_elaP_elap:0:${#_elaP_elap}-$_elaP_dec}" \
"${_elaP_elap:${#_elaP_elap}-_elaP_dec}" "${*}"
fi
$_elaP_setLast && _elaP_last=$_elaP_now
}
export -f elap