Рассчитать среднее время выполнения программы, используя Bash

Question

Чтобы получить время выполнения любого исполняемого файла, скажем, a.out, я могу просто написать time ./a.out.Это выведет реальное время, время пользователя и системное время.

Можно ли написать bash-скрипт, который запускает программу много раз, вычисляет и выводит среднее реальное время выполнения?

Answer 1

Вы можете написать цикл и собрать выходные данные команды time и направить ее к awk для вычисления среднего значения:

avg_time() {
    #
    # usage: avg_time n command ...
    #
    n=$1; shift
    (($# > 0)) || return                   # bail if no command given
    for ((i = 0; i < n; i++)); do
        { time -p "$@" &>/dev/null; } 2>&1 # ignore the output of the command
                                           # but collect time's output in stdout
    done | awk '
        /real/ { real = real + $2; nr++ }
        /user/ { user = user + $2; nu++ }
        /sys/  { sys  = sys  + $2; ns++}
        END    {
                 if (nr>0) printf("real %f\n", real/nr);
                 if (nu>0) printf("user %f\n", user/nu);
                 if (ns>0) printf("sys %f\n",  sys/ns)
               }'
}

Пример:

avg_time 5 sleep 1

будет

real 1.000000
user 0.000000
sys 0.000000

Это может быть легко улучшено до:

• сна в течение заданного промежутка времени между выполнениями
• сна в течение произвольного времени (в течениеопределенный диапазон) между казнями

---

Значение time -p из man time:

   -p
      When in the POSIX locale, use the precise traditional format

      "real %f\nuser %f\nsys %f\n"

      (with  numbers  in seconds) where the number of decimals in the
      output for %f is unspecified but is sufficient to express the
      clock tick accuracy, and at least one.

---

Вы можете проверитьа также этот инструмент командной строки для командной строки:

sharkdp / hyperfine

Answer 2

Общее время выполнения против суммы единственного времени выполнения

Забота! делительная сумма N округляется время выполнения неточно!

Вместо этого мы могли бы разделить общее время выполнения N итерации (по N)

avg_time_alt() { 
    local -i n=$1
    local foo real sys user
    shift
    (($# > 0)) || return;
    { read foo real; read foo user; read foo sys ;} < <(
        { time -p for((;n--;)){ "$@" &>/dev/null ;} ;} 2>&1
    )
    printf "real: %.5f\nuser: %.5f\nsys : %.5f\n" $(
        bc -l <<<"$real/$n;$user/$n;$sys/$n;" )
}

Примечание: Используетсяbc вместо awk для вычисления среднего.Для этого мы создали бы временный файл bc:

printf >/tmp/test-pi.bc "scale=%d;\npi=4*a(1);\nquit\n" 60

. Это вычислило бы ¶ с 60 десятичными знаками и затем тихо завершилось.(Вы можете адаптировать количество десятичных знаков для вашего хоста.)

Демо:

avg_time_alt 1000 sleep .001
real: 0.00195
user: 0.00008
sys : 0.00016

avg_time_alt 1000 bc -ql /tmp/test-pi.bc
real: 0.00172
user: 0.00120
sys : 0.00058

Где Функция Codeforester будет anser:

avg_time 1000 sleep .001
real 0.000000
user 0.000000
sys 0.000000

avg_time 1000 bc -ql /tmp/test-pi.bc
real 0.000000
user 0.000000
sys 0.000000

Альтернатива, вдохновленная ответом Чоробы с использованием Linux's /proc

Хорошо, вы можете рассмотреть:

avgByProc() { 
    local foo start end n=$1 e=$1 values times
    shift;
    export n;
    { 
        read foo;
        read foo;
        read foo foo start foo
    } < /proc/timer_list;
    mapfile values < <(
        for((;n--;)){ "$@" &>/dev/null;}
        read -a endstat < /proc/self/stat
        {
            read foo
            read foo
            read foo foo end foo
        } </proc/timer_list
        printf -v times "%s/100/$e;" ${endstat[@]:13:4}
        bc -l <<<"$[end-start]/10^9/$e;$times"
    )
    printf -v fmt "%-7s: %%.5f\\n" real utime stime cutime cstime
    printf "$fmt" ${values[@]}
}

Это основано на /proc:

man 5 proc | grep [su]time\\\|timer.list | sed  's/^/>   /'
            (14) utime  %lu
            (15) stime  %lu
            (16) cutime  %ld
            (17) cstime  %ld
     /proc/timer_list (since Linux 2.6.21)

Тогда сейчас:

avgByProc 1000 sleep .001
real   : 0.00242
utime  : 0.00015
stime  : 0.00021
cutime : 0.00082
cstime : 0.00020

Где utime и stime представляют время пользователя и системное время для самого себя и cutime и cstime представляют дочернее пользовательское время и дочернее системное время , которые наиболее интересны .

Примечание: В этом случае (sleep) команда не будет использовать много ресурсов.

avgByProc 1000 bc -ql /tmp/test-pi.bc
real   : 0.00175
utime  : 0.00015
stime  : 0.00025
cutime : 0.00108
cstime : 0.00032

Это станет более понятным ... Конечно,как доступ к timer_list и self/stat последовательно, но не атомарно , различия между real (на основе наносекунд) и c?[su]time (основано на галочки т.е.: 1/100-ая сек) может появиться!

Answer 3

Вероятно, проще записать время начала и окончания выполнения и разделить разницу на количество выполнений.

#!/bin/bash
times=10
start=$(date +%s)
for ((i=0; i < times; i++)) ; do
    run_your_executable_here
done
end=$(date +%s)
bc -l <<< "($end - $start) / $times"

Я использовал bc для вычисления среднего значения, так как bash этого не делаетподдержка арифметики с плавающей запятой.

Для большей точности вы можете переключиться на наносекунды:

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

и аналогично для $end.