Вы можете измерить время исполнения части кода, используя функцию time.Since:
start := time.Now() // Код для измерения duration := time.Since(start) // Отформатированная строка, // например, «2h3m0.5s» или «4.503μs» fmt.Println(duration) // Nanoseconds как int64 fmt.Println(duration.Nanoseconds())
Измерение вызова функции
Вы можете отслеживать время выполнения полного вызова функции с помощью этой однострочной записи, которая записывает результат в стандартный поток ошибок.
func foo() < defer duration(track(«foo»)) // Код для измерения >func track(msg string) (string, time.Time) < return msg, time.Now() >func duration(msg string, start time.Time)
Тесты производительности (бенчмарки)
Пакет testing поддерживает тестирование производительности (benchmarking), которое можно использовать для проверки производительности вашего кода.
- Как получить текущую метку времени (timestamp) в Golang
- Количество дней между двумя датами в Golang
- Форматирование времени и даты в Golang
Источник: golang-blog.blogspot.com
Как узнать время запуска любой программы на компьютере
Узнать время выполнения программы
При программировании AVR (ATmegaXX, ATtinyXX) необходимо знать, сколько времени будет выполняться код. Здесь описываются простые правила для расчета этого времени.
Время выполнения ассемблерных инструкций строго привязано к тактовой частоте микроконтроллера AVR, поэтому первое, что нужно узнать — какая у Вас установлена частота ядра F, т. е. на какой частоте работает внутренний тактовый генератор. Обычно частота тактового генератора задается кварцем, тогда она равна частоте, написанной на кварце. Иногда кварц не используется, и запускается не очень точный внутренний RC генератор (никакие внешние компоненты для генератора не нужны), тогда обычно генератор работает на частоте 1 МГц (можно настроить и на частоту 8 МГц). Какой режим используется — определяется внутренними настройками fuses (они еще называются перемычками). Например, для чипа ATmega16 по умолчанию (когда чип приходит чистый с завода) перемычки настроены на работу без кварца, от внутреннего RC генератора на частоте 1 МГц.
Итак, частоту ядра F в Герцах мы знаем. Теперь можно узнать время одного такта TCLK = 1 / F (в секундах). Каждая команда выполняется строго определенное количество тактов (какое количество — зависит от команды). Например, команды ANDI и ORI (которые часто используются при управлении ножками портов) выполняются за 1 такт. Пример расчета длительности выполнения команды ANDI:
F = 12 МГц
TCLK = 1/12000000 = 0.000000083(3) сек = 0.083(3) мкс
Время выполнения команды 0.083 * 1 = 0.083 микросекунды (команда ANDI выполняется за 1 такт).
Таблицу соответствия между командами микроконтроллера и количеством тактов можно найти в даташите на микроконтроллер, см. раздел Instructions Set Summary в конце даташита. В последнем столбце таблицы #Clocks указано число тактов, за которое выполняется команда. Если там стоит одна цифра — например 2, тогда все понятно, команда выполняется 2 такта. Но иногда там стоит 1/2 или 1/2/3.
Время в C++
Это означает для примера 1/2, что команда может выполнится за 1 или 2 такта, что зависит от условия выполнения команды. Например, команда BREQ выполнится за 1 такт, если нет ветвления по условию, и за 2 такта, если произойдет условный переход.
[Расчет выполнения команды на языке Си]
Чтобы узнать, сколько будет выполняться команда на языке Си, нужно пройти её выполнение в отладчике (симуляторе). В режиме просмотра выполняющегося кода есть возможность выбрать просмотр в дизассемблированном виде, тогда будут видны ассемблерные команды и соответствующие им операторы Си. Длительность каждой команды ассемблера можно вычислить, как было показано ранее. Общая длительность выполнения кода на Си будет равна сумме длительностей выполнения составляющих этот код ассемблерных инструкций.
Есть также способ прямого измерения длительности выполнения кода с помощью осциллографа. Для этого выбирают свободную ножку у микроконтроллера, и в начале измеряемого кода ставят установку ножки в 1, а по окончании измеряемого кода устанавливают ножку в 0. Запускают программу на выполнение и осциллографом измеряют длительность импульса.
[Вычисление константы для таймера/счетчика]
Таймеры/счетчики часто используются в программе для отсчета задержек времени. Я обычно настраиваю счетчик таким образом, чтобы его прерывание срабатывало примерно раз в 1 миллисекунду. В этом случае в программе удобно отсчитывать время относительно глобального счетчика (об этом далее). Покажу на таймере 1, как это настраивается и как используется.
//[timer.c]
u32 timestamp=0;
u32 uptime=0;
#define F_CPU 12000000L //частота кварца, Гц
#define TCNT1_1MS (65536-(F_CPU/(256L*1000))) // столько тиков будет делать T/C1 за 1 мс
void SetupTIMER1 ( void )
// 1 TCCR1B = (1 <
TCNT1 = TCNT1_1MS;
// Enable timer 1 overflow interrupt.
TIMSK = (1 <
>
void timePoll ( void )
static u16 timecnt = 100;
TCNT1 = TCNT1_1MS;
TIMSK = (1<
//[timerint.S]
#include
.text
.global TIMER1_OVF_vect
TIMER1_OVF_vect:
;cbi _SFR_IO_ADDR(PORTB), PB7
push R24
;ldi R24, ~(1 <
ldi R24, 0
out _SFR_IO_ADDR(TIMSK), R24
; out 0x39, R24
pop R24
;sbi _SFR_IO_ADDR(PORTB), PB7
reti
Немного комментариев к коду. Константа F_CPU задает частоту микроконтроллера в Гц (обычно частота кварца). Её удобно задать в makefile, если у Вас проект GCC для AVR Studio (тогда в коде её задавать не нужно). Процедура SetupTIMER1 настраивает предделитель частоты тактов для таймера 1 (частота микроконтроллера делится на 256, и получается частота тактов для таймера 1).
Макрос TCNT1_1MS задает константу, которая загружается в таймер после срабатывания прерывания, её значение задается таким образом, что прерывание будет происходить каждую 1 мс. Обычно константу загружают в счетчик таймера при срабатывании прерывания, но в этом примере сделано несколько по-другому — обработчик прерывания таймера просто запрещает прерывание таймера (обработчик прерывания написан на ассемблере), а основная программа процедурой timePoll проверяет — запрещено ли прерывание, и по этому событию снова загружает константу TCNT1_1MS, разрешает прерывание и ведет отсчет глобального времени (в тиках 1 мс — счетчик 32-разрядный счетчик timestamp, в тиках 1 с — 32-разрядный счетчик uptime). Такой вариант обработки прерывания таймера максимально разгружает процессор для выполнения остальных прерываний, что лучше всего подходит для ресурсоемких приложений (например, с применением библиотеки V-USB).
[Отсчет времени в программе с точностью 1 мс]
Если у Вас имеется организованный таким образом глобальный счетчик миллисекундных отсчетов timestamp, то отсчет времени в программе становится тривиальной задачей. Вот пример вычисления задержки в 0.5 секунды:
u32 timecnt = timestamp+500;
while (timestamp
[Ссылки]
Источник: microsin.net
Хотите узнать время выполнения кода – тогда ручной тайминг для вас
Часто у программиста во время работы возникают ситуации, когда необходимо сравнить между собой скорости двух алгоритмов между собой, либо же узнать скорость выполнения того или иного куска кода. Естественно, это можно сделать при помощи профилировщика, но, если программа небольшая по объему или просто профилировщика нет рядом с программистом, лучше всего использовать библиотеку, содержащую функции для манипуляций с датой и временем.
Основная часть
В данной статье рассматривается библиотеки / из языков С /С++. По сути это одна и та же библиотека для разных языков. Чтобы работать со временем в программе на С++ надо подключить библиотеку, написав следующий код: #include . Напомним, что преследуемая цель – узнать продолжительность выполнения куска кода. За это отвечает функция clock(), имеющая такое определение:
clock_t clock( void );
Сlock() возвратит количество временных тактов с начала выполнения программы. В сигнатуре функции видно, что функция возвращает тип clock_t, который аналогичен типу long. Последнее легко проверяется, если посмотреть заголовочный файл, то мы найдем там строку «typedef long clock_t». Надо быть внимательным и следить за возвращаемым значением, потому что функция может вернуть -1.
Такое возвращаемое число, как -1, означает, что невозможно получить системное время. Но это бывает крайне редко, и программист сам должен решить стоит ли ставить проверку или нет.
После возврата значения следует это значение поделить на макрос CLOCKS_PER_SEC. Сам макрос представляет собой константу равную значению 1000. Проделав следующую операцию, мы получим количество пройденных тактов за секунду: clock() / CLOCKS_PER_SEC. Нужно быть внимательным потому, что после деления мы получим целочисленный результат, а необходим вещественный. Поэтому нужно привести к типу double одну из двух операнд, а также вычесть предыдущее время, для того, чтобы узнать длительность выполнения. В итоге получится следующий кусочек кода:
clock_t beg_t; // Хранится начальное время double end_t; // Хранится конечное время beg_t = clock(); // код алгоритма end_t = double(clock() — beg_t) / CLOCKS_PER_SEC; cout
Нюансы при использовании функции clock:
- Вводить информацию промеж двумя вызовами clock() подобает только для тестирования своего консольного вывода или жесткого диска;
- Запрашивать внесение каких-либо данных с устройств ввода пользователей;
- Если при подсчете времени оказалось, что время равно 0, тогда процесс выполняется слишком быстро;
- Между двумя вызовами clock() не следует выделять динамически память для переменных, а также менять содержимое переменных, если эти переменные используются вне этого участка кода.
Приведенный метод замера длительности вычисления того или иного процесса довольно прост в реализации, но в то же самое время – не применим в случае сложных алгоритмов. Для сложных программ куда удобнее использовать профилировщики. Также не следует игнорировать приведенные советы, которые могу привести к весомой погрешности при подсчетах или даже к критически ошибкам.
Источник: owlweb.ru