Bir betiğin yürütme süresini etkili bir şekilde nasıl alabilirim?

Bir betiğin tamamlanma süresini görüntülemek istiyorum.

Şu anda yaptığım şey -

#!/bin/bash
date  ## echo the date at start
# the script contents
date  ## echo the date at end

Bu sadece şovun senaryosunun başlangıç ​​ve bitiş zamanını gösterir. İşlemci zamanı / saat zamanı, vb. Gibi ince taneli bir çıktı görüntülemek mümkün müdür?

Sadece timebetiği aradığınızda kullanın :

time yourscript.sh

Bir timeseçenek değilse,

start=`date +%s`
stuff
end=`date +%s`

runtime=$((end-start))

Sadece timesbetiğinizden çıkarken argüman olmadan arayın .

kshVeya ile bunun yerine zshkullanabilirsiniz time. Bununla birlikte zsh, kullanıcı ve sistem CPU zamanına timeek olarak duvar saati süresini de verir .

Komut dosyanızın çıkış durumunu korumak için şunları yapabilirsiniz:

ret=$?; times; exit "$ret"

Veya ayrıca bir tuzak ekleyebilirsiniz EXIT:

trap times EXIT

Bu şekilde ne zaman kabuk çıkarsa çıkılsın ve çıkış durumu korunur.

$ bash -c 'trap times EXIT; : {1..1000000}'
0m0.932s 0m0.028s
0m0.000s 0m0.000s
$ zsh -c 'trap time EXIT; : {1..1000000}'
shell  0.67s user 0.01s system 100% cpu 0.677 total
children  0.00s user 0.00s system 0% cpu 0.677 total

Ayrıca hepsi dikkat bash, kshve zshbir var $SECONDSotomatik her saniye artırılır alır özel değişkeni. İkisinde de zshve ksh93bu değişken de kayan nokta (yapılabilir typeset -F SECONDSdaha hassas almak için). Bu sadece duvar saati, CPU zamanı değil.

Çoğunluğa geç kaldım, ancak başkalarının arayarak bu konuya karışması durumunda çözümümü (ikinci saniye hassasiyet için) göndermek istedim. Çıktı gün, saat, dakika ve son olarak saniye biçimindedir:

res1=$(date +%s.%N)

# do stuff in here

res2=$(date +%s.%N)
dt=$(echo "$res2 - $res1" | bc)
dd=$(echo "$dt/86400" | bc)
dt2=$(echo "$dt-86400*$dd" | bc)
dh=$(echo "$dt2/3600" | bc)
dt3=$(echo "$dt2-3600*$dh" | bc)
dm=$(echo "$dt3/60" | bc)
ds=$(echo "$dt3-60*$dm" | bc)

printf "Total runtime: %d:%02d:%02d:%02.4f\n" $dd $dh $dm $ds

Umarım birileri bu yararlı buluyor!

Benim yöntemim bash:

# Reset BASH time counter
SECONDS=0
    # 
    # do stuff
    # 
ELAPSED="Elapsed: $(($SECONDS / 3600))hrs $((($SECONDS / 60) % 60))min $(($SECONDS % 60))sec"

#!/bin/bash
start=$(date +%s.%N)

# HERE BE CODE

end=$(date +%s.%N)    
runtime=$(python -c "print(${end} - ${start})")

echo "Runtime was $runtime"

Evet, bu Python'u çağırıyor, ancak bununla yaşayabilirseniz o zaman bu oldukça hoş ve özlü bir çözüm.

Bu soru oldukça eski ama en sevdiğim yolu bulmaya çalışırken bu konu yükseldi ... ve kimsenin bahsetmediğine şaşırdım:

perf stat -r 10 -B sleep 1

'perf', çekirdek içerisinde 'tools / perf' başlığı altında bulunan ve genellikle ayrı bir paket olarak kurulabilen bir performans analiz aracıdır (CentOS'ta 'perf' ve Debian / Ubuntu'da 'linux-tools'). Linux Kernal perf Wiki hakkında daha fazla bilgi var.

'Perf stat' çalıştırmak, en sonunda ortalama yürütme süresi de dahil olmak üzere oldukça fazla ayrıntı verir:

1.002248382 seconds time elapsed                   ( +-  0.01% )

Zamanlarını ölçmek için komutlardan önce eklenebilecek küçük bir kabuk işlevi:

tm() {
  s=$(date +%s)
  $@
  rc=$?
  echo "took $[$(date +%s)-$s] seconds. return code $rc" >&2
  return $rc
}

Ardından, komut dosyanızda veya komut satırınızda şöyle kullanın:

tm the_original_command with all its parameters

İşte Alex'in cevabının bir çeşidi. Sadece dakikaları ve saniyeleri önemsiyorum, fakat farklı formatlarda da olmasını istedim. Bu yüzden bunu yaptım:

start=$(date +%s)
end=$(date +%s)
runtime=$(python -c "print '%u:%02u' % ((${end} - ${start})/60, (${end} - ${start})%60)")

#!/bin/csh
#PBS -q glean
#PBS -l nodes=1:ppn=1
#PBS -l walltime=10:00:00
#PBS -o a.log
#PBS -e a.err
#PBS -V
#PBS -M shihcheng.guo@gmail.com
#PBS -m abe
#PBS -A k4zhang-group
START=$(date +%s)
for i in {1..1000000}
do
echo 1
done
END=$(date +%s)
DIFF=$(echo "$END - $START" | bc)
echo "It takes DIFF=$DIFF seconds to complete this task..."

Sadece bash kullanarak kabuk betiğinin bir kısmının (veya betiğin tamamı için geçen sürenin) zaman süresini ölçmek ve hesaplamak da mümkündür :

start=$SECONDS

... # do time consuming stuff

end=$SECONDS

şimdi sadece ya şu farkı yazdırabilirsiniz:

echo "duration: $((end-start)) seconds."

Yalnızca artan süreye ihtiyacınız varsa şunları yapın:

echo "duration: $((SECONDS-start)) seconds elapsed.."

Süreyi bir değişkende de saklayabilirsiniz:

let diff=end-start

Şahsen, tüm script kodumu şöyle bir "main" işlevine yerleştirmeyi seviyorum:

main () {
 echo running ...
}

# stuff ...

# calling the function at the very end of the script
time main

timeBu senaryoda komutu kullanmanın ne kadar kolay olduğuna dikkat edin . Açıkçası senaryo ayrıştırma zamanı dahil tam zamanı ölçmüyorsunuz, ancak çoğu durumda yeterince doğru buluyorum.

#!/bin/bash
begin=$(date +"%s")

Script

termin=$(date +"%s")
difftimelps=$(($termin-$begin))
echo "$(($difftimelps / 60)) minutes and $(($difftimelps % 60)) seconds elapsed for Script Execution."

SECONDSYalnızca ikinci seviye ayrıntı düzeyi ile sınırlı olan zamanlama işlevi herhangi bir harici komut kullanmaz:

time_it() {
  local start=$SECONDS ts ec
  printf -v ts '%(%Y-%m-%d_%H:%M:%S)T' -1
  printf '%s\n' "$ts Starting $*"
  "$@"; ec=$?
  printf -v ts '%(%Y-%m-%d_%H:%M:%S)T' -1
  printf '%s\n' "$ts Finished $*; elapsed = $((SECONDS-start)) seconds"
  # make sure to return the exit code of the command so that the caller can use it
  return "$ec"
}

Örneğin:

time_it sleep 5

verir

2019-03-30_17:24:37 Starting sleep 5 2019-03-30_17:24:42 Finished
sleep 5; elapsed = 5 seconds