Program yürütme zamanı nasıl ölçülür ve değişken içinde saklanır

Bash (v4 +) komut dosyasındaki belirli işlemlerin ne kadar sürdüğünü bulmak için, çıktıyı time"ayrı ayrı" komutundan ayrıştırmak ve (sonunda) bir Bash değişkeninde ( let VARNAME=...) yakalamak istiyorum .

Şimdi, kullanıyorum time -f '%e' ...(daha ziyade command time -f '%e' ...Bash'in yerleşik olması nedeniyle), fakat zaten yürütülen komutun çıktısını yönlendirdiğim için, timekomutun çıktısını yakalamak için nasıl gideceğim konusunda gerçekten kayboldum . Temel olarak burada sorun çıkış ayırmak için bir timekomutun (ler) çıkışından.

İstediğim şey, bir komutun başlatılması ile tamamlanması arasındaki süreyi saniye cinsinden (tamsayılar) sayma işlevidir . timeKomut veya ilgili yerleşik olmak zorunda değildir .

Düzenleme: Aşağıdaki iki yararlı cevap göz önüne alındığında, iki açıklama eklemek istedim.

1. Yürütülen komutun çıktısını çöpe atmak istemiyorum, ancak stdout'ta mı yoksa stderr'de mi sonuçlanacağı önemli değil.
2. Dolaylı bir yaklaşımdan dolaysız bir yaklaşımı tercih ederim (yani çıktıları ara dosyalarda saklamak yerine doğrudan yakalamak).

dateŞimdiye kadar kullanan çözüm, istediklerime yaklaşıyor.

timeÇıktısını bir var içine almak için aşağıdakileri kullanın:

usr@srv $ mytime="$(time ( ls ) 2>&1 1>/dev/null )"
usr@srv $ echo "$mytime"

real    0m0.006s
user    0m0.001s
sys     0m0.005s

Ayrıca tek bir zaman türü isteyebilirsiniz, örneğin utime:

usr@srv $ utime="$( TIMEFORMAT='%lU';time ( ls ) 2>&1 1>/dev/null )"
usr@srv $ echo "$utime"
0m0.000s

Ayrıca kullanabileceğiniz zaman kazanmak için date +%s.%N, yürütmeden önce ve sonra alın ve farkları hesaplayın:

START=$(date +%s.%N)
command
END=$(date +%s.%N)
DIFF=$(echo "$END - $START" | bc)
# echo $DIFF

Bash olarak, yapının çıktısı timestandart hatasına gider ve etkilediği boru hattının standart hatasını yönlendirebilirsiniz. O halde, çıkış ve hata streamas yazar bir komutla başlayalım: sh -c 'echo out; echo 1>&2 err'. Komutun hata akışını çıktı ile karıştırmamak için, komutun hata akışını timegeçici olarak farklı bir dosya tanımlayıcıya aktarabiliriz:

{ time -p sh -c 'echo out; echo 1>&2 err' 2>&3; }

Bu outfd 1, errfd 3 ve fd 2'nin zamanlarıdır:

{ time -p sh -c 'echo out; echo 1>&2 err' 2>&3; } \
    3> >(sed 's/^/ERR:/') 2> >(sed 's/^/TIME:/') > >(sed 's/^/OUT:/')

errFd 2 ve fd 3'teki zamanlar için daha keyifli olur , bu yüzden onları değiştiririz, hantaldır çünkü iki dosya tanımlayıcısını değiştirmenin doğrudan bir yolu yoktur:

{ { { time -p sh -c 'echo out; echo 1>&2 err' 2>&3; } 3>&2 2>&4; } 4>&3; } 3> >(sed 's/^/TIME:/') 2> >(sed 's/^/ERR:/') > >(sed 's/^/OUT:/')

Bu, komutun çıktısını nasıl işleyebileceğinizi gösterir, ancak hem komutun çıktısını hem de zamanını yakalamak istiyorsanız daha çok çalışmanız gerekir. Geçici bir dosya kullanmak bir çözümdür. Aslında, hem komutun standart hatasını hem de standart çıktısını yakalamanız gerekiyorsa tek güvenilir çözüm budur. Ancak, aksi takdirde, tüm çıktıyı yakalayabilir ve timetahmin edilebilir bir formata sahip olmanızın avantajlarından yararlanabilirsiniz ( POSIX formatını veya bash'a özgü değişkeni kullanmak time -piçin kullanıyorsanız ).TIMEFORMAT

nl=$'\n'
output=$(TIMEFORMAT='%R %U %S %P'; mycommand)
set ${output##*$nl}; real_time=$1 user_time=$2 system_time=$3 cpu_percent=$4
output=${output%$nl*}

Yalnızca duvar saati süresini önemsiyorsanız, dateönce ve sonra çalıştırmak basit bir çözümdür (harici komutu yüklemek için harcanan fazladan zaman nedeniyle biraz daha kesinse).

Zamanla, stdout'ta komut çıktısı çıkar ve stderr'de zaman çıkar. Böylece, onları ayırmak için şunları yapabilirsiniz:

command time -f '%e' [command] 1>[command output file] 2>[time output file]

Fakat şimdi zaman bir dosyada. Bash'in stderr'i doğrudan bir değişkene koyabileceğini sanmıyorum. Komutun çıktısını bir yere yönlendirmeyi sakıncası yoksa, şunları yapabilirsiniz:

FOO=$((( command time -f '%e' [command]; ) 1>outputfile; ) 2>&1; )

Bunu yaptığınızda, komutun çıktısı girecek outputfileve çalıştırılması gereken süre girecektir $FOO.

Varsanız bash(değil sh) ve ikinci saniye doğruluğa ihtiyacınız YOKTUR, çağrıyı datetamamen atlayıp ek işlemler oluşturmadan, birleştirilmiş çıktıyı ayırmak zorunda kalmadan ve çıktıyı yakalamak ve ayrıştırmak zorunda kalmadan yapmak için aramayı tamamen atlayabilirsiniz. herhangi bir komuttan:

# SECONDS is a bash special variable that returns the seconds since set.
SECONDS=0
mycmd <infile >outfile 2>errfile
DURATION_IN_SECONDS=$SECONDS
# Now `$DURATION_IN_SECONDS` is the number of seconds.

Bu amaçla , kabuklu ve kabuğundan çalışan işlemler için biriken kullanıcı ve sistem zamanlarını basan times(dan time) kullanımı muhtemelen daha iyidir bash, örnek kullanım:

$ (sleep 2; times) | (read tuser tsys; echo $tuser:$tsys)
0m0.001s:0m0.003s

Daha help -m timesfazla bilgi için bakınız:

OSX'deyken önceki yanıtları bir araya getirme konusunda

ProductName:    Mac OS X
ProductVersion: 10.11.6
BuildVersion:   15G31+

beğenebilirsin

microtime() {
    python -c 'import time; print time.time()'
}
compute() {
    local START=$(microtime)
    #$1 is command $2 are args
    local END=$(microtime)
    DIFF=$(echo "$END - $START" | bc)
    echo "$1\t$2\t$DIFF"
}

Kur /bin/time(örn. pacman -S time)

Yani -fbayrak çalışırken hata yerine :

$ time -f %e sleep 0.5
bash: -f: command not found

real    0m0.001s
user    0m0.001s
sys     0m0.001s

Aslında kullanabilirsiniz:

$ /bin/time -f %e sleep 0.5
0.50

Ve ne istersen elde et - değişkende zaman (örnek, %egeçen sürelerde, diğer seçenekleri kontrol etmek için kullanır man time):

#!/bin/bash
tmpf="$(mktemp)"
/bin/time -f %e -o "$tmpf" sleep 0.5
variable="$(cat "$tmpf")"
rm "$tmpf"

echo "$variable"

Tıpkı yukarıdaki ifadelerle çalışırken ve özellikle Grzegorz'in cevabını alarak başa çıkarken olduğu gibi. Ubuntu 16.04 Xenial sistemimde bu iki sonucu gördüğüme şaşırdım:

$ which time
/usr/bin/time

$ time -f %e sleep 4
-f: command not found
real    0m0.071s
user    0m0.056s
sys     0m0.012s

$ /usr/bin/time -f %e sleep 4
4.00

Başka takma adlarım yok ve bu yüzden bunun neden olduğunu bilmiyorum.

Bunu deneyin, argümanlarla basit bir komut çalıştırır ve $ real $ user $ sys zamanını koyar ve çıkış kodunu korur.

Ayrıca, gerçek kullanıcı sys dışında herhangi bir değişkende alt kabukları çatallamaz ya da trample etmez ve betiğin çalışmasına başka şekilde müdahale etmez.

timer () {
  { time { "$@" ; } 2>${_} {_}>&- ; } {_}>&2 2>"/tmp/$$.$BASHPID.${#FUNCNAME[@]}"
  set -- $?
  read -d "" _ real _ user _ sys _ < "/tmp/$$.$BASHPID.${#FUNCNAME[@]}"
  rm -f "/tmp/$$.$BASHPID.${#FUNCNAME[@]}"
  return $1
}

Örneğin

  timer find /bin /sbin /usr rm /tmp/
  echo $real $user $sys

not: sadece basit komut, bileşenleri bir alt kabukta çalıştırılan bir boru hattının değil sadece komut satırının

Bu sürüm, 3 kez alması gereken değişkenlerin adını 1 $ olarak belirlemenizi sağlar:

timer () {
  { time { "${@:4}" ; } 2>${_} {_}>&- ; } {_}>&2 2>"/tmp/$$.$BASHPID.${#FUNCNAME[@]}"
  set -- $? "$@"
  read -d "" _ "$2" _ "$3" _ "$4" _ < "/tmp/$$.$BASHPID.${#FUNCNAME[@]}"
  rm -f "/tmp/$$.$BASHPID.${#FUNCNAME[@]}"
  return $1
}

Örneğin

  timer r u s find /bin /sbin /usr rm /tmp/
  echo $r $u $s

ve zaman zaman sürtünmekten kaçınmak için özyinelemeli olarak çağrılırsa yararlı olabilir; ancak daha sonra rus vb. kullanımlarında yerel olarak ilan edilmelidir.

http://blog.sam.liddicott.com/2016/01/timeing-bash-commands.html