Evrensel bash olmayan 'zaman' kıyaslama alternatifi? [kapalı]

Farklı kabuklar arasındaki komut çalıştırmak kez karşılaştırarak, bazı SE cevaplar kullanarak önermek bashs' dahili time , komuta şöyle:

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

... vs , her kabuğun test etmesi için. Bu tür ölçütler, her kabuğun kendini yüklemesi ve başlatması için geçen süreyi ortadan kaldırmaz . Örneğin, yukarıdaki komutların her ikisinin de erken bir disketin okuma hızına sahip yavaş bir cihazda depolandığını varsayalım (124KB / s), dash( ~ 150K yürütülebilir) kabuktan yaklaşık 7 kat daha hızlı yüklenecektir bash( ~ 1M ) yükleme süresi timesayıları çarpıtır - bu mermilerin ön yükleme süreleri , mermiler yüklendikten sonrafoo.sh her merminin altında çalışma sürelerinin ölçülmesi ile ilgisizdir .

Çalıştırılabilir komut zamanlama çalıştırmak için en iyi taşınabilir ve genel util nedir dahilinde her kabuk? Yukarıdaki kod şöyle görünecektir:

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

Not: hiçbiri taşınabilir veya genel olmadığı için kabuk yerleşik time komutları yoktur .

Daha da iyisi, util bir kabuğun dahili komutları ve boru hatları tarafından harcanan zamanı, kullanıcı önce bir komut dosyasına sarmak zorunda kalmadan kıyaslayabiliyorsa. Bunun gibi yapay sözdizimi yardımcı olacaktır:

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

Bazı mermiler timebunu başarabilir. Örneğin bash -c "time while false ; do : ; done"işler. Sisteminizde neyin işe yarayıp neyin işe yaramadığını görmek için şunu deneyin:

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

timePOSIX tarafından belirtildiğini ve POSIX'in bahsettiği tek seçeneğin ( -p) çeşitli kabuklar tarafından doğru bir şekilde desteklendiğini AFAICT ile not etmelisiniz :

$ 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

Yüksek çözünürlüklü bir zamanlayıcıyı destekleyen GNU date komutunu kullanıyorum :

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

"$@" &> /dev/null

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

Ve sonra senaryoyu şöyle çağırıyorum:

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

Çıkış birimi milisaniye cinsindendir.

Yardımcı timeprogram genellikle fark ettiğiniz gibi kabuğun içine yerleştirilmiştir, bu da onu "nötr" bir zamanlayıcı olarak işe yaramaz hale getirir.

Bununla birlikte, yardımcı program, genellikle /usr/bin/timeönerdiğiniz zamanlama deneylerini gerçekleştirmek için kullanılabilecek harici bir yardımcı program olarak da kullanılabilir .

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

İşte bir çözüm:

1. her merminin kendini yüklemesi ve başlatması için geçen süreyi [s] ortadan kaldırır

2. her kabuğun içinden çalıştırılabilir

3. Kullanımları

   hiçbir kabuk yerleşik timekomut içermez , çünkü hiçbiri taşınabilir veya genel değildir

4. POSIX uyumlu tüm mermilerde çalışır.
5. C derleyicili veya önceden bir C yürütülebilir dosyası derleyebileceğiniz tüm POSIX uyumlu ve XSI uyumlu sistemlerde çalışır .
6. Tüm kabuklarda aynı zamanlama uygulamasını kullanır.

İki bölüm vardır: tamamlanan gettimeofday, ancak daha taşınabilir olan kısa bir C programı clock_gettimeve bir komut dosyasını kaynaklamanın her iki tarafını okuyan mikrosaniye hassasiyetli bir saat almak için bu programı kullanan kısa bir kabuk komut dosyası. C programı, zaman damgasında bir saniyenin altında bir hassasiyet elde etmenin tek taşınabilir ve minimum tepegöz yoludur.

İşte C programı 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);
}

Ve kabuk betiği timer:

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

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

Bu standart kabuk komut dilidir ve bcherhangi bir POSIX uyumlu kabuk altında komut dosyası olarak çalışmalıdır.

Bunu şu şekilde kullanabilirsiniz:

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

Sistem veya kullanıcı süresini ölçmez, sadece monoton olmayan duvar saati geçen süreyi ölçer. Komut dosyası yürütülürken sistem saati değişirse, bu yanlış sonuçlar verir. Sistem yük altındaysa, sonuç güvenilir olmayacaktır. Daha iyi bir şeyin kabuklar arasında taşınabilir olabileceğini düşünmüyorum.

Değiştirilmiş bir zamanlayıcı komut dosyası, evalkomut dosyalarının dışındaki komutları çalıştırmak için kullanılabilir .

Agc tarafından sağlanan giriş sayesinde büyük parçalarda /proc/uptimeve dc/ bc/ kullanarak birçok kez revize edilmiş çözüm :awk

#!/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."

Açıkça /proc/uptimevar olduğunu ve belli bir formu olduğunu varsayar .