Alternatif tolok ukur `waktu` non-bash universal? [Tutup]

Untuk membandingkan menjalankan kali skrip antara kerang yang berbeda, beberapa jawaban SE menyarankan menggunakan bash's built-in time perintah, seperti:

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

... dll , untuk setiap shell untuk diuji. Tolok ukur seperti itu gagal menghilangkan waktu yang dibutuhkan setiap shell untuk memuat dan menginisialisasi sendiri . Sebagai contoh, misalkan kedua perintah di atas disimpan pada perangkat yang lambat dengan kecepatan baca dari floppy disk awal , (124KB / dtk), dash(a ~ 150K dieksekusi) akan memuat sekitar 7x lebih cepat daripada bash( ~ 1M ), shell waktu pemuatan akan memiringkan timeangka - waktu pra-pemuatan kerang-kerang tersebut tidak relevan untuk mengukur waktu proses di foo.shbawah setiap kerang setelah kerang dimuat.

Apa kegunaan portabel dan umum terbaik untuk menjalankan skrip waktu yang dapat dijalankan dari dalam setiap shell? Jadi kode di atas akan terlihat seperti:

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

NB: tidak ada perintah built-in shell time, karena tidak ada yang portabel atau umum.

Lebih baik lagi jika util juga dapat membuat tolok ukur waktu yang diambil oleh perintah internal dan jaringan pipa shell, tanpa pengguna harus terlebih dahulu membungkusnya dalam skrip. Sintaks buatan seperti ini akan membantu:

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

Beberapa kerang timedapat mengatur ini. Misalnya bash -c "time while false ; do : ; done"berfungsi. Untuk melihat apa yang berfungsi, (dan tidak) pada sistem Anda, coba:

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

Anda harus mencatat bahwa timeditentukan oleh POSIX , dan AFAICT satu-satunya opsi yang POSIX sebutkan ( -p) didukung dengan benar oleh berbagai shell:

$ 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

Saya menggunakan perintah GNU date , yang mendukung timer resolusi tinggi:

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

"$@" &> /dev/null

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

Dan kemudian saya memanggil skrip seperti ini:

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

Unit output dalam milidetik.

The timeutilitas biasanya dibangun ke shell, seperti yang Anda telah memperhatikan, yang membuatnya berguna sebagai timer "netral".

Namun, utilitas biasanya juga tersedia sebagai utilitas eksternal /usr/bin/time,, yang dapat digunakan untuk melakukan eksperimen pengaturan waktu yang Anda usulkan.

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

Berikut ini solusinya:

1. menghilangkan [s] waktu yang dibutuhkan untuk setiap shell untuk memuat dan menginisialisasi sendiri

2. dapat dijalankan dari dalam setiap shell

3. Penggunaan

   tidak ada timeperintah bawaan shell , karena tidak ada yang portabel atau umum

4. Bekerja di semua shell yang kompatibel dengan POSIX.
5. Bekerja pada semua sistem yang kompatibel dengan POSIX dan XSI dengan kompiler C , atau di mana Anda dapat mengkompilasi C yang dapat dieksekusi di muka.
6. Menggunakan implementasi waktu yang sama pada semua shell.

Ada dua bagian: program C pendek yang membungkus gettimeofday, yang sudah usang tetapi masih lebih portabel daripada clock_gettime, dan skrip shell pendek yang menggunakan program itu untuk mendapatkan jam presisi mikrodetik membaca kedua sisi sumber skrip. Program C adalah satu-satunya cara portabel dan overhead minimal untuk mendapatkan ketepatan sub-detik pada timestamp.

Berikut adalah program C 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);
}

Dan skrip shell timer:

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

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

Ini adalah bahasa perintah shell standar dan bcdan harus berfungsi sebagai skrip di bawah setiap shell yang kompatibel dengan POSIX.

Anda dapat menggunakan ini sebagai:

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

Itu tidak mengukur waktu sistem atau pengguna, hanya jam dinding non-monoton yang berlalu. Jika jam sistem berubah selama eksekusi skrip, ini akan memberikan hasil yang salah. Jika sistem sedang dimuat, hasilnya akan tidak dapat diandalkan. Saya tidak berpikir sesuatu yang lebih baik bisa dibawa-bawa di antara cangkang.

evalSkrip pengatur waktu yang dimodifikasi dapat digunakan untuk menjalankan perintah di luar skrip.

Beberapa kali solusi yang direvisi menggunakan /proc/uptimedan dc/ bc/ awksebagian besar berkat input oleh AGC :

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

Berasumsi jelas bahwa /proc/uptimeada dan memiliki bentuk tertentu.