Измерение времени выполнения программного кода является важной задачей как для разработчиков, так и для пользователей. Это позволяет оптимизировать работу приложения, находить узкие места и ускорять процесс выполнения операций.
В языке программирования C для замера времени наиболее часто используется функция clock(). Однако, следует помнить, что эта функция замеряет процессорное время, а не время, затраченное на выполнение программы. Как правило, процессорное время только приближенно соответствует времени, затраченному на выполнение программы.
Прежде, чем перейти к замеру времени выполнения кода, необходимо дать определение процессорного и реального времени.
Процессорное время — это время, которое затрачивает процессор на обработку задач и является наиболее точным определением времени выполнения интересующего нас кода. Однако, она не учитывает весь объем работы, связанной с запуском и завершением процесса, таких как загрузка программы в память, открытие файла или установление соединения с сервером.
Время в C++
Реальное время замеряет продолжительность работы программы вместе со всеми дополнительными операциями, связанными с ее запуском и завершением. Это может быть полезным при определении времени, необходимого для выполнения определенной операции на устройстве или приложении.
Как же замерить время выполнения кода в C?
Самый простой способ замерить время выполнения операции — использование функции clock(). Она возвращает количество тиков процессора, затраченных на выполнения операции. Однако, нам нужно конвертировать это число в единицы, которые мы можем понимать.
int main()
clock_t start, end;
double cpu_time_used;
/* Тут должен находиться код, который мы хотим замерить */
end = clock();
cpu_time_used = ((double) (end — start)) / CLOCKS_PER_SEC;
printf(«Время выполнения кода: %f секундn», cpu_time_used);
Как видно, мы сначала запускаем функцию clock() до выполнения интересующей нас операции, а затем после выполнения. Потом мы вычисляем разницу между этими двумя значениями, и конвертируем ее в секунды с помощью константы CLOCKS_PER_SEC.
Также, стоит отметить, что время, затраченное на выполнение операции, может сильно зависеть от характеристик компьютера, на котором она запущена, а также от того, запускается ли она в режиме отладки.
Помимо функции clock(), в C также есть специализированные библиотеки для замера времени, такие как gettimeofday() или time(). Однако, они часто требуют большего количества кода для использования, чем функция clock(), и могут быть менее точными в некоторых случаях.
Наконец, не забывайте, что замер времени выполнения кода может быть полезен только при знании, какие операции занимают больше всего времени. Поэтому, важно брать образцы кода не только при максимальных нагрузках, но и при разных условиях использования программы. Только так можно получить действительно полезную информацию о времени выполнения кода.
Продвинутое программирование по Си 1: Функции time, ctime
Похожие записи:
- Как замерить время выполнения кода в pytest?
- Как замерить время выполнения кода в миллисекундах?
- Как замерить время выполнения PHP скрипта?
- Как замерить время выполнения автоматического теста?
- Как найти время выполнения алгоритма с известной сложностью при 100n, зная время выполнения при n?
Источник: qaa-engineer.ru
Русские Блоги
Как точно измерить время выполнения кода под кейлом?
Сфокусируйся на, Star StandardНет Нет хорошего содержания
Эта статья передается из: Рыба Eagle разговаривает с одним чипом микрокомпьютер
Я считаю, что 51 видеоизовисты Guo Tianxiang’s 51 Taoists должны знать, что учитель представил функцию работы кода KEIL в видео:
Рыба Eagle всегда хотел использовать эту функцию, но очень, к сожалению, я обнаружил, что на этот раз не точен!
Учитель Го сказал, что на этот раз подразделение Второй (SEC), рассчитывается из первого кода однополома, но когда вы действительно используете Проверка осциллографа На этот раз беден (потому что, когда я не знаю, когда микроконтроллер начинает бегать, я могу видеть только разницу времени), вы найдете это время неточности.
Следовательно, предыдущая рыба орел примет шаги для обеспечения точности и бросит следующие шаги для обеспечения точности.
1, перемещение осциллографа (эм, очень тяжелый)
2, найдите строку DuPont (лучше проверить хорошее и плохое из DuPont)
3. Вставьте высокий код низкого уровня до и после того, как тестовый код (выходной высокий и низкий уровень позволяет дисплею осциллографа)
4, иногда код может быть выполнен только один раз, либо изменять код для цикла запуска или использовать одностороннюю функцию осциллографа.
Когда вы выполнили вышеуказанные шаги, вы действительно можете начать работу тестирования.
Итак, пожалуйста, спросите своих друзей, эти шаги вам нужно проводить больше времени?
Десять минут до половины часа почти, если что-то трудно найти, больше времени!
Нет ли лучше? С помощью этих чистого программного обеспечения вы можете проверить время выполнения кода, мы можем сделать?
Таким образом, рыбный орел всегда помнил это, и он всегда хочет найти удобный и простой метод измерения.
До одного дня рыба орел завершила функцию ядра UCOS II Sense, , то есть эта вещь:
Рыба орел переиздается измерение времени Кейла.
Это может быть известно из рыбы орел, что на этот раз довольно точный, так понятно, насколько клей может получить точное время, почему это выделенное время отображения не допускается?
Позже, орел рыбы увидела это в окне KEIL (окна отладки):
Я пошел, есть небольшое окно специальный дисплей, затем Щелкните правой кнопкой мыши И было это:
Когда вы серьезно соблюдаете, я нашел несколько вариантов, но время все еще неверно (единица: второе).
Когда рыба орел завершила восприятие ядра, окно еще раз тестировалось и обнаружило, что это правда (гм, не может ругаться).
Здесь рыбные уши понимают, а не клей не может отображать время, но не установить точный.
Так как его настроить? Fisherk думаетSTM32 Инструмент отладки ITM«В заметках есть ключевая операция, то есть Калькулярная часовая частота 。
Таким образом, рыба орел изменит по умолчанию от 10 м до 72 м F103 и нашел осциллограф, а еда как тигр, наконец, получил результат.
Правда! Быстро вы подозреваете жизнь!
Да, Онлайн симуляция Далее вам нужно только добавить эту настройку с помощью обычных настроек эмулятора, вы можете получить нужное время.
а также Имитация программного обеспечения Далее, просто установите эту точную настройку Внешний хрусталь Частота вибрации , Вы можете измерить время выполнения (STM32 F103, симуляция программного обеспечения F4 невозможно)
Так как вы измеряете время?
существовать Регистрация окна Отображаемое время — это время от односмысленного первого кода. На этот раз накапливается. Если вы измереете на этот раз, вы должны записать время до тестового кода, затем запустить код, запись снова, дважды вещество является кодом время выполнения.
Этот метод хороший, но Fishk имеет лучший способ.
Вы видели вариант?
Люди могут сбросить время (сбросить) время, например, орел Fishey, который теперь отображается с T1 (T0 и Регистрация окна В то же время одинаково, не верь, что вы можете посмотреть), просто сбросьте этот T1 (Top Tought), а затем сохраните код, отображается T1, — это время выполнения этого кода.
Таким образом, вы можете легко измерить измерение времени кода.
Поскольку мы получаем результаты, которые мы хотим, мы подумаем о следующих вопросах:
1. Почему время после настройки?
2, как это измерить время?
3, какова его точность измерения?
4, каков предел на этот метод измерения?
На самом деле, эти несколько вопросов связаны с DWT (этот модуль Fish Eagle пишет во многих нотах) этот периферийный модуль.
C-C++: как измерять процессорное время
2016-04-23 в 22:02, admin , рубрики: benchmark, C, c++, cpu time, время, кроссплатформенность, оптимизация кода, Программирование, производительность
КДПВ
От переводчика:
Большинство моих знакомых для измерения времени в разного вида бенчмарках в С++ используют chrono или, в особо запущенных случаях, ctime . Но для бенчмаркинга гораздо полезнее замерять процессорное время. Недавно я наткнулся на статью о кроссплатформенном замере процессорного времени и решил поделиться ею тут, возможно несколько увеличив качество местных бенчмарков.
P.S. Когда в статье написано «сегодня» или «сейчас», имеется ввиду «на момент выхода статьи», то есть, если я не ошибаюсь, март 2012. Ни я, ни автор не гарантируем, что это до сих пор так.
P.P.S. На момент публикации оригинал недоступен, но хранится в кэше Яндекса
Функции API, позволяющие получить процессорное время, использованное процессом, отличаются в разных операционных системах: Windows, Linux, OSX, BSD, Solaris, а также прочих UNIX-подобных ОС. Эта статья предоставляет кросс-платформенную функцию, получающую процессорное время процесса и объясняет, какие функции поддерживает каждая ОС.
Как получить процессорное время
Процессорное время увеличивается, когда процесс работает и потребляет циклы CPU. Во время операций ввода-вывода, блокировок потоков и других операций, которые приостанавливают работу процессора, процессорное время не увеличивается пока процесс снова не начнет использовать CPU.
Разные инструменты, такие как ps в POSIX, Activity Monitor в OSX и Task Manager в Windows показывают процессорное время, используемое процессами, но часто бывает полезным отслеживать его прямо из самого процесса. Это особенно полезно во время бенчмаркинга алгоритмов или маленькой части сложной программы. Несмотря на то, что все ОС предоставляют API для получения процессорного времени, в каждой из них есть свои тонкости.
Код
Функция getCPUTime( ) , представленная ниже, работает на большинстве ОС (просто скопируйте код или скачайте файл getCPUTime.c). Там, где это нужно, слинкуйтесь с librt, чтобы получить POSIX-таймеры (например, AIX, BSD, Cygwin, HP-UX, Linux и Solaris, но не OSX). В противном случае, достаточно стандартных библиотек.
Далее мы подробно обсудим все функции, тонкости и причины, по которым в коде столько #ifdef ‘ов.
getCPUTime.c
/* * Author: David Robert Nadeau * Site: http://NadeauSoftware.com/ * License: Creative Commons Attribution 3.0 Unported License * http://creativecommons.org/licenses/by/3.0/deed.en_US */ #if defined(_WIN32) #include #elif defined(__unix__) || defined(__unix) || defined(unix) || (defined(__APPLE__) defined(__MACH__)) #include #include #include #include #else #error «Unable to define getCPUTime( ) for an unknown OS.» #endif /** * Returns the amount of CPU time used by the current process, * in seconds, or -1.0 if an error occurred. */ double getCPUTime( ) < #if defined(_WIN32) /* Windows ————————————————— */ FILETIME createTime; FILETIME exitTime; FILETIME kernelTime; FILETIME userTime; if ( GetProcessTimes( GetCurrentProcess( ), exitTime, userTime ) != -1 ) < SYSTEMTIME userSystemTime; if ( FileTimeToSystemTime( userSystemTime ) != -1 ) return (double)userSystemTime.wHour * 3600.0 + (double)userSystemTime.wMinute * 60.0 + (double)userSystemTime.wSecond + (double)userSystemTime.wMilliseconds / 1000.0; >#elif defined(__unix__) || defined(__unix) || defined(unix) || (defined(__APPLE__) defined(__MACH__)) /* AIX, BSD, Cygwin, HP-UX, Linux, OSX, and Solaris ——— */ #if defined(_POSIX_TIMERS) (_POSIX_TIMERS > 0) /* Prefer high-res POSIX timers, when available. */ < clockid_t id; struct timespec ts; #if _POSIX_CPUTIME >0 /* Clock ids vary by OS. Query the id, if possible. */ if ( clock_getcpuclockid( 0, ts ) != -1 ) return (double)ts.tv_sec + (double)ts.tv_nsec / 1000000000.0; > #endif #if defined(RUSAGE_SELF) < struct rusage rusage; if ( getrusage( RUSAGE_SELF, >#endif #if defined(_SC_CLK_TCK) < const double ticks = (double)sysconf( _SC_CLK_TCK ); struct tms tms; if ( times( >#endif #if defined(CLOCKS_PER_SEC) < clock_t cl = clock( ); if ( cl != (clock_t)-1 ) return (double)cl / (double)CLOCKS_PER_SEC; >#endif #endif return -1; /* Failed. */ >
Использование
Чтобы замерить процессорное время алгоритма, вызовите getCPUTime( ) до и после запуска алгоритма, и выведите разницу. Не стоит предполагать, что значение, возвращенное при единичном вызове функции, несет какой-то смысл.
double startTime, endTime; startTime = getCPUTime( ); . endTime = getCPUTime( ); fprintf( stderr, «CPU time used = %lfn», (endTime — startTime) );
Обсуждение
Каждая ОС предоставляет один или несколько способов получить процессорное время. Однако некоторые способы точнее остальных.
| AIX | yes | yes | yes | yes |
| BSD | yes | yes | yes | yes |
| HP-UX | yes | yes | yes | yes |
| Linux | yes | yes | yes | yes |
| OSX | yes | yes | yes | |
| Solaris | yes | yes | yes | yes |
| Windows | yes |
Каждый из этих способов подробно освещен ниже.
GetProcessTimes( )
На Windows и Cygwin (UNIX-подобная среда и интерфейс командной строки для Windows), функция GetProcessTimes( ) заполняет структуру FILETIME процессорным временем, использованным процессом, а функция FileTimeToSystemTime( ) конвертирует структуру FILETIME в структуру SYSTEMTIME, содержащую пригодное для использования значение времени.
typedef struct _SYSTEMTIME < WORD wYear; WORD wMonth; WORD wDayOfWeek; WORD wDay; WORD wHour; WORD wMinute; WORD wSecond; WORD wMilliseconds; >SYSTEMTIME, *PSYSTEMTIME;
Доступность GetProcessTimes( ): Cygwin, Windows XP и более поздние версии.
Получение процессорного времени:
#include . FILETIME createTime; FILETIME exitTime; FILETIME kernelTime; FILETIME userTime; if ( GetProcessTimes( GetCurrentProcess( ), exitTime, userTime ) != -1 ) < SYSTEMTIME userSystemTime; if ( FileTimeToSystemTime( userSystemTime ) != -1 ) return (double)userSystemTime.wHour * 3600.0 + (double)userSystemTime.wMinute * 60.0 + (double)userSystemTime.wSecond + (double)userSystemTime.wMilliseconds / 1000.0; >
clock_gettme( )
На большинстве POSIX-совместимых ОС, clock_gettime( ) (смотри мануалы к AIX, BSD, HP-UX, Linux и Solaris) предоставляет самое точное значение процессорного времени. Первый аргумент функции выбирает «clock id», а второй это структура timespec , заполняемая использованным процессорным временем в секундах и наносекундах. Для большинства ОС, программа должна быть слинкована с librt.
Однако, есть несколько тонкостей, затрудняющих использование этой функции в кросс-платформенном коде:
- Функция является опциональной частью стандарта POSIX и доступна только если _POSIX_TIMERS определен в значением больше 0. На сегодняшний день, AIX, BSD, HP-UX, Linux и Solaris поддерживают эту функцию, но OSX не поддерживает.
- Структура timespec , заполняемая функцией clock_gettime( ) может хранить время в наносекундах, но точность часов отличается в разных ОС и на разных системах. Функция clock_getres( ) возвращает точность часов, если она вам нужна. Эта функция, опять-таки, является опциональной частью стандарта POSIX, доступной только если _POSIX_TIMERS больше нуля. На данный момент, AIX, BSD, HP-UX, Linux и Solaris предоставляют эту функцию, но в Solaris она не работает.
- стандарт POSIX определяет имена нескольких стандартных значений «clock id», включая CLOCK_PROCESS_CPUTIME_ID , чтобы получить процессорное время процесса. Тем не менее, сегодня BSD и HP-UX не имеют этого id, и взамен определяют собственный id CLOCK_VIRTUAL для процессорного времени. Чтобы запутать все ещё больше, Solaris определяет оба этих, но использует CLOCK_VIRTUAL для процессорного времени потока, а не процесса.
| AIX | CLOCK_PROCESS_CPUTIME_ID |
| BSD | CLOCK_VIRTUAL |
| HP-UX | CLOCK_VIRTUAL |
| Linux | CLOCK_PROCESS_CPUTIME_ID |
| Solaris | CLOCK_PROCESS_CPUTIME_ID |
- Вместо того, чтобы использовать одну из констант, объявленных выше, функция clock_getcpuclockid( ) возвращает таймер для выбранного процесса. Использование процесса 0 позволяет получить процессорное время текущего процесса. Однако, это ещё одна опциональная часть стандарта POSIX и доступна только если _POSIX_CPUTIME больше 0. На сегодняшний день, только AIX и Linux предоставляют эту функцию, но линуксовские include-файлы не определяют _POSIX_CPUTIME и функция возвращает ненадёжные и несовместимые с POSIX результаты.
- Функция clock_gettime( ) может быть реализована с помощью регистра времени процессора. На многопроцессорных системах, у отдельных процессоров может быть несколько разное восприятие времени, из-за чего функция может возвращать неверные значения, если процесс передавался от процессора процессору. На Linux, и только на Linux, это может быть обнаружено, если clock_getcpuclockid( ) возвращает не-POSIX ошибку и устанавливает errno в ENOENT . Однако, как замечено выше, на Linux clock_getcpuclockid( ) ненадежен.
На практике из-за всех этих тонкостей, использование clock_gettime( ) требует много проверок с помощью #ifdef и возможность переключиться на другую функцию, если она не срабатывает.
Доступность clock_gettime( ): AIX, BSD, Cygwin, HP-UX, Linux и Solaris. Но clock id на BSD и HP-UX нестандартные.
Доступность clock_getres( ): AIX, BSD, Cygwin, HP-UX и Linux, но не работает Solaris.
Доступность clock_getcpuclockid( ): AIX и Cygwin, не недостоверна на Linux.
Получение процессорного времени:
#include #include . #if defined(_POSIX_TIMERS) (_POSIX_TIMERS > 0) clockid_t id; struct timespec ts; #if _POSIX_CPUTIME > 0 /* Clock ids vary by OS. Query the id, if possible. */ if ( clock_getcpuclockid( 0, ts ) != -1 ) return (double)ts.tv_sec + (double)ts.tv_nsec / 1000000000.0; #endif
getrusage( )
На всех UNIX-подобных ОС, функция getrusage( ) это самый надежный способ получить процессорное время, использованное текущим процессом. Функция заполняет структуру rusage временем в секундах и микросекундах. Поле ru_utime содержит время проведенное в user mode, а поле ru_stime — в system mode от имени процесса.
Внимание: Некоторые ОС, до широкого распространения поддержки 64-бит, определяли функцию getrusage( ) , возвращающую 32-битное значение, и функцию getrusage64( ) , возвращающую 64-битное значение. Сегодня, getrusage( ) возвращает 64-битное значение, а getrusage64( ) устарело.
Доступность getrusage( ): AIX, BSD, Cygwin, HP-UX, Linux, OSX, and Solaris.
Получение процессорного времени:
#include #include . struct rusage rusage; if ( getrusage( RUSAGE_SELF,
times( )
На всех UNIX-подобных ОС, устаревшая функция times( ) заполняет структуру tms с процессорным временем в тиках, а функция sysconf( ) возвращает количество тиков в секунду. Поле tms_utime содержит время, проведенное в user mode, а поле tms_stime — в system mode от имени процесса.
Внимание: Более старый аргумент функции sysconf( ) CLK_TCK устарел и может не поддерживаться в некоторых ОС. Если он доступен, функция sysconf( ) обычно не работает при его использовании. Используйте _SC_CLK_TCK вместо него.
Доступность times( ): AIX, BSD, Cygwin, HP-UX, Linux, OSX и Solaris.
Получение процессорного времени:
#include #include . const double ticks = (double)sysconf( _SC_CLK_TCK ); struct tms tms; if ( times(
clock( )
На всех UNIX-подобных ОС, очень старая функция clock( ) возвращает процессорное время процесса в тиках, а макрос CLOCKS_PER_SEC количество тиков в секунду.
Заметка: Возвращенное процессорное время включает в себя время проведенное в user mode И в system mode от имени процесса.
Внимание: Хотя изначально CLOCKS_PER_SEC должен был возвращать значение, зависящее от процессора, стандарты C ISO C89 и C99, Single UNIX Specification и стандарт POSIX требуют, чтобы CLOCKS_PER_SEC имел фиксированное значение 1,000,000, что ограничивает точность функции микросекундами. Большинство ОС соответствует этим стандартам, но FreeBSD, Cygwin и старые версии OSX используют нестандартные значения.
Внимание: На AIX и Solaris, функция clock( ) включает процессорное время текущего процесса И и любого завершенного дочернего процесса для которого родитель выполнил одну из функций wait( ) , system( ) или pclose( ) .
Внимание: В Windows, функция clock( ) поддерживается, но возвращает не процессорное, а реальное время.
Доступность clock( ): AIX, BSD, Cygwin, HP-UX, Linux, OSX и Solaris.
Получение процессорного времени:
#include . clock_t cl = clock( ); if ( cl != (clock_t)-1 ) return (double)cl / (double)CLOCKS_PER_SEC;
Другие подходы
Существуют и другие ОС-специфичные способы получить процессорное время. На Linux, Solarisи некоторых BSD, можно парсить /proc/[pid]/stat, чтобы получить статистику процесса. На OSX, приватная функция API proc_pidtaskinfo( ) в libproc возвращает информацию о процессе.
Также существуют открытые библиотеки, такие как libproc, procps и Sigar.
На UNIX существует несколько утилит позволяющих отобразить процессорное время процесса, включая ps, top, mpstat и другие. Можно также использовать утилиту time, чтобы отобразить время, потраченное на команду.
На Windows, можно использовать диспетчер задач, чтобы мониторить использование CPU.
На OSX, можно использовать Activity Monitor, чтобы мониторить использование CPU. Утилита для профайлинга Instruments поставляемая в комплекте с Xcode может мониторить использование CPU, а также много других вещей.
Downloads
- getCPUTime.c реализует выше описанную функцию на C. Скомпилируйте её любым компилятором C и слинкуйте с librt, на системах где она доступна. Код лицензирован под Creative Commons Attribution 3.0 Unported License.
Смотри также
Связанные статьи на NadeauSoftware.com
- C/C++ tip: How to measure elapsed real time for benchmarking объясняет как получить реальное время, чтобы измерить прошедшее время для куска кода, включая время, потраченное на I/O или пользовательский ввод.
- C/C++ tip: How to use compiler predefined macros to detect the operating system объясняет как использовать макросы #ifdef для ОС-специфичного кода. Часть из этих методов использовано в этой статье, чтобы определить Windows, OSX и варианты UNIX.
Статьи в интернете
- Процессорное время на википедии объясняет, что такое процессорное время.
- CPU Time Inquiry на GNU.org объясняет как использовать древнюю функцию clock( ).
- Determine CPU usage of current process (C++ and C#) предоставляет код и объяснения для получения процессорного времени и другой статистики на Windows.
- Posix Options на Kernel.org объясняет опциональные фичи и константы POSIX, включая _POSIX_TIMERS и _POSIX_CPUTIME.
Источник: www.pvsm.ru