Я думаю, что лучший способ обнаружить это использование getClientRects()
, кажется, что каждый прямоугольник имеет одинаковую высоту, поэтому мы можем выкачать число строк с числом различных значений top
.
getClientRects
работают как , этот
function getRowRects(element) {
var rects = [],
clientRects = element.getClientRects(),
len = clientRects.length,
clientRect, top, rectsLen, rect, i;
for(i=0; i clientRect.right ? rect.right : clientRect.right;
rect.width = rect.right - rect.left;
}
else {
rects.push({
top: clientRect.top,
right: clientRect.right,
bottom: clientRect.bottom,
left: clientRect.left,
width: clientRect.width,
height: clientRect.height
});
}
}
return rects;
}
getRowRects
работает как этот
, вы можете обнаружить как this
Вы можете написать цикл и собрать выходные данные команды 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
:
blockquote>-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.
Вы можете захотеть Также проверьте этот инструмент для командной строки:
Care! делительная сумма N округленных времени выполнения является неточным! [1139 ]
Вместо этого мы могли бы разделить общее время выполнения 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
/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[@]}
}
Это основано на [ 1113]:
blockquote>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
представляют время пользователя и [ 1130] системное время для самого bash, а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-й секунде) могут появиться!
Вероятно, легче записать время начала и окончания выполнения и разделить разницу на количество выполнений.
#!/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
.