В последнее время я обнаружил необходимость точного измерения времени выполнения кода C Все программы, приведенные в следующих.:
- gettimeofday(2)
- rdtsc/rdtscp
- clock_gettime(2)
Ниже мы представим эти три программы, основные проблемы являются точность, точность и стоимость вызовов. Среда обсуждения является система Linux X86_64 работает на Intel X86, номер версии ядра выше , чем 2.6.32.
gettimeofday(2)
Первый GetTimeOfDay (2), прототип функции выглядит следующим образом:
#include int gettimeofday(struct timeval *tv, struct timezone *tz); struct timeval < time_t tv_sec; /* seconds */ suseconds_t tv_usec; /* microseconds */ >; struct timezone < int tz_minuteswest; /* minutes west of Greenwich */ int tz_dsttime; /* type of DST correction */ >;
С горы структурного определения, точность времени, полученная с помощью этой функции микросекунды (США, 10 ^ -6s).
Системное время, полученное с помощью этой функции заключается в использовании времени стены XTIME и обработки мигов. Стеновые начинается с UTC 1970-01-01 00:00:00, и RTC (часы реального) чипа, запасенной батареи материнской платы сохраняется. Миги этого количества дней после запуска ядра Linux, а Ядро Linux начинает увеличивать частоту от 100 до 1000 с версии 2.5, то есть, система рабочей частоты 1s / 1000 = 1 мс (миллисекунды). Можно видеть, что только эти два источника не могут достичь точности США. Однако, в ядре Linux, то HRTIMER таймер высокой точности (High Resolution Timer) также корректирует XTime, который поддерживает даже NS (наносекунды, 10 ^ -9) точность времени.
Время выполнения программы на с++
существовать Linux x86_64 В системе, реализация GetTimeOfDay использует «Матчи с памятью в состояние пользователя и состояние ядра, данные по обслуживанию ядра, состояние пользователя права чтения», так что вызов функции не нужен попасть в ядро, чтобы получить данные, т.е. Linux x86_64 В разрядной системе, стоимость вызова этой функции, по существу, последовательный (менее 1 мс).
В целом, микросекунды уровни уже достаточно для общего времени, эта функция также очень часто на метку времени выхода журнала, но все еще немного не хватает в связи с высокими требованиями к точности.
rdtsc/rdtscp
Далее идет RDTSC этой директивы CPU. Смысл этой инструкции является значением регистра READ TSC, то Time Stamp Счетчик регистра. Начиная с процессора Pentium, многие из 80×86 микропроцессоров Intel представит 64-разрядные регистры TSC для временной метки счетчика. Этот регистр дополнения 1 при поступлении каждого тактового сигнала.
Тогда приращение этого значения связан с частотой процессора, и кластер 1000, который является 1000000 раз в секунду. Инструкция RDTSC считывает численное значение регистра TSC, а значение стоимости сохраняется в регистре EAX, а высокий 32 бит сохраняется в регистре EDX. Это так легко писать код, чтобы прочитать это значение с внутренним связыванием НКИ:
typedef unsigned long long cycles_t; inline cycles_t currentcycles()
Но этот метод синхронизации легко найти оппозиции, и есть несколько общих заявлений:
Ответы на вопросы 3: Замер времени исполнения программы.
- CPU обрабатывается от Pentium Pro будет обеспечивать переупорядочивание команды.
- Частота процессора может изменяться, например, режим экономии энергии.
- Невозможно гарантировать, что ТСК регистр каждого ядра процессора синхронизирован.
Это хорошо, чтобы изменить порядок, используйте инструкцию CPUID для того, если процессор является относительно новым, используйте инструкцию RDTSCP непосредственно, это уже чувство порядка. Что касается проблемы изменения частоты, если это новый процессор, вы можете /proc/cpuinfo Посмотрите в файл, если функции, связанные с TSC имеют constant_tsc с участием nonstop_tsc Не беспокойтесь об этом. бывший Constant TSC means that the TSC does not change with CPU frequency changes, however it does change on C state transitions ,последний The Non-stop TSC has the properties of both Constant and Invariant TSC Отказ Однако, нет никакого решения между несколькими процессорами. Интересно, что передняя levelOfDay (2) прикреплен к XTime и тиков, когда вернулись, и есть также значение с помощью регистра TSC.
Кстати, наша сцена время выполнения теста одного ядра. Можно запустить время выполнения несколько раз, а не код продукта, который длится в течение длительного времени, так что можно использовать команду RDTSCP.
clock_gettime(2)
Наконец-то clock_gettime(2) Прототип выглядит следующим образом:
#include int clock_gettime(clockid_t clk_id, struct timespec *tp); struct timespec < time_t tv_sec; /* seconds */ long tv_nsec; /* nanoseconds */ >;
Из структурного определения, это функция сбора времени для NS (наносекунд, 10 ^ -9) точность уровня. clk_id Параметр определяет тип имеющегося времени со следующим значением:
- CLOCK_REALTIME Система в реальном времени времени, начиная с UTC 1970-01-01 00:00:00
- CLOCK_MONOTONIC Начните время выполнения синхронизации из системы, нет времени сна
- CLOCK_MONOTONIC_RAW (Начиная с Linux 2.6.28; Linux-Specific) Похожие CLOCK_MONOTONIC , Но на основе оригинального оборудования данных, не зависит от изменения времени NTP
- CLOCK_PROCESS_CPUTIME_ID Время, что система CPU тратит, когда процесс выполняется для текущего кода.
- CLOCK_THREAD_CPUTIME_ID Время система CPU тратит, когда текущий код выполняется.
Из параметров, как правило, используют в первый раз CLOCK_REALTIM Параметр Е, использовать этот параметр немного похож gettimeofday(2) Однако, точность высока (10 ^ -9 против 10 ^ -6). На самом деле, когда время CLOCK_PROCESS_CPUTIME_ID или CLOCK_THREAD_CPUTIME_ID Час, clock_gettime(2) Есть также инструкции RDTSC, чтобы получить время. Конкретная стоимость звонка у меня нет теста. Некоторые люди в референции связанные экспериментов и дать соответствующие тестовые данные, вы можете обратиться к нему.
Источник: russianblogs.com
Как измерить время выполнения программы и сохранить его в переменной
Чтобы выяснить, сколько времени занимают определенные операции в скрипте Bash (v4 +), я хотел бы проанализировать выходные данные time команды «по отдельности» и (в конечном итоге) перехватить ее в переменной Bash ( let VARNAME=. ).
Теперь я использую time -f ‘%e’ . (или, скорее, command time -f ‘%e’ . из-за встроенного Bash), но так как я уже перенаправил вывод выполненной команды, я действительно потерян, чтобы узнать, как я собираюсь захватить вывод time команды. В основном проблема здесь , чтобы отделить выход из time от выхода выполненной команды (ов).
Что мне нужно, так это функциональность подсчета количества времени в секундах (целых числах) между началом команды и ее завершением. Это не обязательно должна быть time команда или соответствующий встроенный элемент.
Изменить: учитывая два полезных ответа ниже, я хотел бы добавить два разъяснения.
- Я не хочу отбрасывать вывод выполненной команды, но на самом деле не имеет значения, окажется ли он на stdout или stderr.
- Я бы предпочел прямой подход, а не косвенный (т. Е. Перехватывать вывод напрямую, а не сохранять его в промежуточных файлах).
Решение, использующее date до сих пор, подходит к тому, что я хочу.
Самый прямой способ получить данные и обработать их, продолжая при этом нормально работать, — это сделать это в программе на C, используя fork() , execvp() и wait3()/wait4() . В конечном итоге это то, что время и друзья делают. Я не знаю простого способа сделать это в bash / perl без перенаправления в файл или подобного подхода.
Существует связанный с этим вопрос , который вы могли бы найти интересное здесь происходит .
Чтобы получить выходные данные time в var, используйте следующее:
Вы также можете просто запросить один тип времени, например, utime:
Чтобы получить время, которое вы также можете использовать date +%s.%N , возьмите его до и после выполнения и рассчитайте разницу:
START=$(date +%s.%N) command END=$(date +%s.%N) DIFF=$(echo «$END — $START» | bc) # echo $DIFF
Я не хотел выбрасывать вывод команды. Поэтому я думаю, что ваш третий блок кода ближе всего к тому, что я имел в виду. Хотя я бы написал последний как DIFF=$((END-START)) , используя арифметические выражения. 🙂 . Спасибо за ответ. +1
К вашему сведению, форматирование даты% N не работает в Mac OS X, оно просто возвращает «N». Хорошо в Ubuntu.
Обратите внимание, что хотя time (cmd) 2> something работа по перенаправлению вывода синхронизации выполняется file , она не предназначена (согласно документации), не используется в других оболочках, где time есть ключевое слово, и может рассматриваться как ошибка . Я бы не стал полагаться на это, так как это может не сработать в будущих версиях bash .
В bash выходные данные time конструкции возвращаются к стандартной ошибке, и вы можете перенаправить стандартную ошибку конвейера, на которую она влияет. Итак , давайте начнем с командой , которая записывает его вывода и ошибок streamas: sh -c ‘echo out; echo 1> echo 1> >
Это записывает out в fd 1, err в fd 3 и время в fd 2:
time -p sh -c ‘echo out; echo 1> > 3> >(sed ‘s/^/ERR:/’) 2> >(sed ‘s/^/TIME:/’) > >(sed ‘s/^/OUT:/’)
Было бы приятнее иметь err на fd 2 и время на fd 3, поэтому мы поменяем их местами, что обременительно, потому что нет прямого способа поменять местами два дескриптора файла:
time -p sh -c ‘echo out; echo 1> > 3> > 4> > 3> >(sed ‘s/^/TIME:/’) 2> >(sed ‘s/^/ERR:/’) > >(sed ‘s/^/OUT:/’)
Это показывает, как вы можете постобработать выходные данные команды, но если вы хотите захватить как выходные данные команды, так и ее время, вам нужно работать усерднее. Использование временного файла является одним из решений. Фактически, это единственное надежное решение, если вам нужно зафиксировать как стандартную ошибку команды, так и ее стандартный вывод. Но в противном случае вы можете захватить весь вывод и использовать тот факт, что он time имеет предсказуемый формат (если вы используете, time -p чтобы получить формат POSIX или TIMEFORMAT переменную, специфичную для bash ).
nl=$’n’ output=$(TIMEFORMAT=’%R %U %S %P’; mycommand) set $output##*$nl>; real_time=$1 user_time=$2 system_time=$3 cpu_percent=$4 output=$output%$nl*>
Если вы заботитесь только о времени настенных часов, запуск date до и после является простым решением (если немного более неточным из-за дополнительного времени, потраченного на загрузку внешней команды).
Источник: qastack.ru
C Программа измеряет время выполнения инструкции
Мне нужно найти время, необходимое для выполнения одной или нескольких инструкций, и распечатать его в миллисекундах. Может кто-нибудь поделиться небольшим фрагментом кода для этого.
Спасибо .. Мне нужно использовать эту меру времени, необходимого для выполнения некоторых инструкций в моем проекте.
Инструкция? В миллисекундах? Я думаю, вы говорите о древней вычислительной машине. Вы можете измерить это секундомером. — valdo
Очень смешно. Но спасибо — Romaan
Альтернативой является чтение ассемблерного кода, сгенерированного вашим компилятором (попробуйте ключ -S с gcc), а затем посмотрите количество тактовых циклов для каждой ассемблерной инструкции в документации для целевого процессора. — potrzebie
3 ответы
#include main() < clock_t t1=clock(); printf(«Dummy Statementn»); clock_t t2=clock(); printf(«The time taken is.. %g «, (t2-t1));
ответ дан 23 мая ’17, 13:05
Выполнение одной инструкции займет намного меньше 1 миллисекунды. И если вы пытаетесь измерить более одной инструкции, это усложнится (как насчет цикла, который вызывает инструкцию несколько раз).
Кроме того, большинство функций синхронизации, которые вы можете использовать, таковы: Функции. Это означает, что они также будут выполнять инструкции. Если вы хотите рассчитать время выполнения одной инструкции, лучше всего посмотреть характеристики процессора, который вы используете, и посмотреть, сколько циклов она занимает.
Программно это сделать невозможно.
Поскольку вы обновили свой вопрос, чтобы теперь обратиться к некоторые инструкции. Вы можете измерять время менее миллисекунды на некоторые процессоры. Хорошо бы знать окружение. Это будет работать на x86 и linux, другие среды будут другими.
Часы получают время позволяет получить субнаносекундную точность. Или вы можете вызвать инструкцию rdstc самостоятельно (удачи в этом на многопроцессорной или smp-системе — вы могли измерять не то, например, что инструкция выполняется на разных процессорах).
Источник: stackovergo.com