у меня есть программа на C, которая стремится работать параллельно на нескольких процессорах. Мне нужно иметь возможность записывать время выполнения (которое может быть от 1 секунды до нескольких минут). Я искал ответы, но все они, похоже, предлагают использовать clock() функция, которая затем включает в себя вычисление количества часов, взятых программой, разделенной на Clocks_per_second значение.
Я не уверен, как Clocks_per_second стоимость рассчитывается?
в Java, я просто взял текущее время в миллисекундах до и после выполнения.
есть ли подобная вещь в C? Я посмотрел, но, похоже, не могу найти способ получить что-то лучше, чем второе разрешение.
Я также знаю, что профилировщик будет вариантом, но я хочу реализовать таймер сам.
автор: Mohan
13 ответов
CLOCKS_PER_SEC — константа, которая объявляется в . Чтобы получить время процессора, используемое задачей в приложении C, используйте:
clock_t begin = clock(); /* here, do your time-consuming job */ clock_t end = clock(); double time_spent = (double)(end — begin) / CLOCKS_PER_SEC;
обратите внимание, что это возвращает время в виде с плавающей точкой. Это может быть более точным, чем второй (например, вы измеряете 4.52 секунды). Точность зависит от архитектуры; на современных системах вы легко получаете 10 мс или ниже, но на старых машинах Windows (с эпохи Win98) это было ближе к 60 мс.
Ответы на вопросы 3: Замер времени исполнения программы.
clock() стандартный C; он работает «везде.» Существуют системные функции, такие как getrusage() в Unix-подобных системах.
в Java System.currentTimeMillis() не измеряет то же самое. Это «настенные часы»: он может помочь вам измерить, сколько времени потребовалось для выполнения программы, но он не говорит вам, сколько времени процессора было использовано. В многозадачных системах (т. е. во всех) они могут быть совершенно разными.
автор: Thomas Pornin
Если вы используете оболочку Unix для запуска, вы можете использовать команду time.
$ time ./a.out
предполагая a.out как исполняемый файл даст u время, необходимое для запуска этого
вы функционально хотите этого:
#include struct timeval tv1, tv2; gettimeofday( /* stuff to do! */ gettimeofday( printf («Total time = %f secondsn», (double) (tv2.tv_usec — tv1.tv_usec) / 1000000 + (double) (tv2.tv_sec — tv1.tv_sec));
обратите внимание, что измеряется в микросекундах, а не только секунд.
автор: Wes Hardaker
в простой ванили C:
#include #include int main() < clock_t tic = clock(); my_expensive_function_which_can_spawn_threads(); clock_t toc = clock(); printf(«Elapsed: %f secondsn», (double)(toc — tic) / CLOCKS_PER_SEC); return 0; >
автор: Alexandre C.
большинство простых программ имеют время вычисления в миллисекундах. Так что, я полагаю, вы найдете это полезным.
#include #include int main() < clock_t start = clock(); // Execuatable code clock_t stop = clock(); double elapsed = (double)(stop — start) * 1000.0 / CLOCKS_PER_SEC; printf(«Time elapsed in ms: %f», elapsed); >
Если вы хотите вычислить время выполнения всей программы, и вы находитесь в системе Unix, запустите программу с помощью времени такой time ./a.out
Как измерить время выполнения кода | Изучение С++ для начинающих. Урок #145
автор: adimoh
многие ответы предлагали clock() а то CLOCKS_PER_SEC С time.h . Это, вероятно, плохая идея, потому что это то, что моя говорит:
/* ISO/IEC 9899:1990 7.12.1: The macro `CLOCKS_PER_SEC’ is the number per second of the value returned by the `clock’ function. */ /* CAE XSH, Issue 4, Version 2: The value of CLOCKS_PER_SEC is required to be 1 million on all XSI-conformant systems. */ # define CLOCKS_PER_SEC 1000000l # if !defined __STRICT_ANSI__ !defined __USE_XOPEN2K /* Even though CLOCKS_PER_SEC has such a strange value CLK_TCK presents the real value for clock ticks per second for the system. */ # include extern long int __sysconf (int); # define CLK_TCK ((__clock_t) __sysconf (2)) /* 2 is _SC_CLK_TCK */ # endif
так CLOCKS_PER_SEC может быть определено как 1000000, в зависимости от того, какие параметры вы используете для компиляции, и поэтому это не кажется хорошим решением.
автор: Stephen
вы должны учитывать, что измерения времени это заняло программу для выполнения, во многом зависит от нагрузки, которую машина имеет в этот конкретный момент.
зная, что способ получения текущего времени в C может быть достигнут разными способами, Проще:
#include #define CPU_TIME (getrusage(RUSAGE_SELF, time_t start, end; double first, second; // Save user and CPU start time time( first = CPU_TIME; // Perform operations . // Save end time time( second = CPU_TIME; printf(«cpu : %.2f secsn», second — first); printf(«user : %d secsn», (int)(end — start)); >
надеюсь, что это помогает.
автор: redent84
ANSI C указывает только функции времени второй точности. Однако, если вы работаете в среде POSIX вы можете использовать gettimeofday() функция, которая обеспечивает разрешение микросекунд времени, прошедшего с эпохи UNIX.
в качестве примечания я бы не рекомендовал использовать clock (), так как он плохо реализован на многих(если не на всех?) системы и не точны, кроме того, что это относится только к тому, как долго ваша программа потратила на процессор, а не всего срок службы программы, который, согласно вашему вопросу, я предполагаю, что вы хотели бы измерить.
автор: Shinnok
каждое решение не работает в моей системе.
Я могу использовать
#include double difftime(time_t time1, time_t time0);
автор: Ankit Chilamatur
#include #include int main() < clock_t begin=clock(); int i; for(i=0;i<100000;i++)< printf(«%d»,i); >clock_t end=clock(); printf(«Time taken:%lf»,(double)(end-begin)/CLOCKS_PER_SEC); >
эта программа будет работать как шарм.
автор: Ravi Kumar Yadav
(все ответы здесь отсутствуют, если ваш сисадмин изменяет системное время, или ваш часовой пояс имеет разные зимние и Соммер — времена. Следовательно. )
в linux используйте: clock_gettime(CLOCK_MONOTONIC_RAW, Это не влияет, если системный администратор изменяет время, или вы живете в стране с зимним временем, отличным от летнего, и т. д.
#include #include #include /* for sleep() */ int main() < struct timespec begin, end; clock_gettime(CLOCK_MONOTONIC_RAW, sleep(1); // waste some time clock_gettime(CLOCK_MONOTONIC_RAW, printf («Total time = %f secondsn», (end.tv_nsec — begin.tv_nsec) / 1000000000.0 + (end.tv_sec — begin.tv_sec)); >
man clock_gettime гласит:
CLOCK_MONOTONIC Clock that cannot be set and represents monotonic time since some unspecified starting point. This clock is not affected by discontinuous jumps in the system time (e.g., if the system administrator manually changes the clock), but is affected by the incremental adjustments performed by adjtime(3) and NTP.
автор: JohnSll
Томас Pornin как макросы:
#define TICK(X) clock_t X = clock() #define TOCK(X) printf(«time %s: %g sec.n», (#X), (double)(clock() — (X)) / CLOCKS_PER_SEC)
используйте его так:
TICK(TIME_A); functionA(); TOCK(TIME_A); TICK(TIME_B); functionB(); TOCK(TIME_B);
time TIME_A: 0.001652 sec. time TIME_B: 0.004028 sec.
автор: Alex Ling
сравнение времени выполнения алгоритма пузырьковой сортировки и сортировки выбором У меня есть программа, которая сравнивает время выполнения пузырьковой сортировки и сортировки выбором. Чтобы узнать время выполнения блока кода, вычислите время до и после блока по
clock_t start=clock(); … clock_t end=clock(); CLOCKS_PER_SEC is constant in time.h library
#include #include #include int main() < int a[10000],i,j,min,temp; for(i=0;i<10000;i++) < a[i]=rand()%10000; >//The bubble Sort clock_t start,end; start=clock(); for(i=0;i<10000;i++) < for(j=i+1;j<10000;j++) < if(a[i]>a[j]) < int temp=a[i]; a[i]=a[j]; a[j]=temp; >> > end=clock(); double extime=(double) (end-start)/CLOCKS_PER_SEC; printf(«ntExecution time for the bubble sort is %f secondsn «,extime); for(i=0;i <10000;i++) < a[i]=rand()%10000; >clock_t start1,end1; start1=clock(); // The Selection Sort for(i=0;i<10000;i++) < min=i; for(j=i+1;j<10000;j++) < if(a[min]>a[j]) < min=j; >> temp=a[min]; a[min]=a[i]; a[i]=temp; > end1=clock(); double extime1=(double) (end1-start1)/CLOCKS_PER_SEC; printf(«n»); printf(«tExecution time for the selection sort is %f secondsnn», extime1); if(extime1extime) printf(«tBubble sort is faster than Selection sort by %f secondsnn», extime1 — extime); else printf(«tBoth algorithms have the same execution timenn»); >
Источник: askdev.ru
Как найти время выполнения команды или процесса в Linux
Мануал
Автор cryptoparty На чтение 5 мин Опубликовано 13.11.2018
Вероятно, вы знаете время начала команды / процесса и как долго процесс выполняется в Unix-подобных системах.
Но когда вы его закончили и / или какое общее время, затраченное на выполнение команды / процесса?
В Unix-подобных системах есть утилита с именем «GNU time», специально предназначенная для этой цели.
Используя утилиту Time, мы можем легко измерить общее время выполнения команды или программы в операционных системах Linux.
Хорошо, что команда «Time» поставляется в большинстве дистрибутивов Linux, поэтому вам не нужно беспокоиться об установке.
Найти время выполнения команды или процесса в Linux
Чтобы измерить время выполнения команды / программы, просто запустите.
$ /usr/bin/time -p ls
$ time ls
dir1 dir2 file1 file2 mcelog real 0m0.007s user 0m0.001s sys 0m0.004s
$ time ls -a . .bash_logout dir1 file2 mcelog .sudo_as_admin_successful .. .bashrc dir2 .gnupg .profile .wget-hsts .bash_history .cache file1 .local .stack real 0m0.008s user 0m0.001s sys 0m0.005s
Вышеуказанные команды отображают общее время выполнения команды «ls».
Замените «ls» любой командой / процессом по вашему выбору, чтобы найти общее время выполнения.
- real – возвращает общее время, затраченное командой / программой,
- user – указывает время, затраченное программой в пользовательском режиме,
- sys – указывает время, затраченное программой в режиме ядра.
time и /usr/bin/time
Как вы могли заметить, в приведенных выше примерах мы использовали две команды «time» и «/usr/bin/time».
Итак, вы можете задаться вопросом, в чем разница между ними.
Сначала давайте посмотрим, что на самом деле «timeя» использует команду «type».
Для тех, кто не знает, команда Type используется для получения информации о команде Linux.
$ type -a time time is a shell keyword time is /usr/bin/time
Как видите time – две штуки
- Ключевое слово, встроенное в оболочку BASH
- Исполняемый файл – /usr/bin/time
Поскольку ключевые слова оболочки имеют приоритет над исполняемыми файлами, когда вы просто запускаете runmimommand без полного пути, вы запускаете встроенную команду оболочки.
Но, когда вы запускаете /usr/bin/time, вы запускаете реальную программу времени GNU time.
Итак, чтобы получить доступ к реальной команде, вам может потребоваться указать ее явный путь.
Встроенное ключевое слово оболочки «time» доступно в большинстве оболочек, таких как BASH, ZSH, CSH, KSH, TCSH и т. д.
Ключевое слово оболочки «time» имеет меньше опций, чем исполняемые файлы.
Единственный вариант, который вы можете использовать в ключе «time», – это -p.
Теперь вы знаете, как найти общее время выполнения данной команды / процесса, используя команду «time».
Хотите узнать немного больше об утилите «GNU time»? Читайте дальше!
Краткое введение в программу «GNU time»
Программа GNU time запускает команду / программу с заданными аргументами и суммирует использование системных ресурсов в качестве стандартного вывода после завершения команды.
В отличие от ключевого слова time, программа GNU time не просто отображает время, используемое командой / процессом, но и другие ресурсы, такие как память, вызовы ввода-вывода и IPC.
Типичным синтаксисом команды Time является:
/usr/bin/time [options] command [arguments. ]
options в приведенном выше синтаксисе ссылаются на набор флагов, которые могут использоваться командой time для выполнения определенной функциональности.
Список доступных опций приведен ниже^
- -f, -format – Используйте этот параметр, чтобы указать формат вывода по вашему желанию.
- -p, -portability – Использовать переносимый формат вывода.
- -o file, -output = FILE – Записывает вывод в FILE вместо отображения в качестве стандартного вывода.
- -a, -append – Добавить файл в файл вместо перезаписывания.
- -v, -verbose – Этот параметр отображает подробное описание вывода утилиты «время».
- -Quiet – этот параметр запрещает утилиту времени «время» сообщать о статусе программы.
- При использовании программы «GNU time» без каких-либо параметров вы увидите вывод, как показано ниже.
$ /usr/bin/time wc /etc/hosts 9 28 273 /etc/hosts 0.00user 0.00system 0:00.00elapsed 66%CPU (0avgtext+0avgdata 2024maxresident)k 0inputs+0outputs (0major+73minor)pagefaults 0swaps
Если вы запустите ту же команду с встроенным ключевым словом «time», результат будет немного другим:
$ time wc /etc/hosts 9 28 273 /etc/hosts real 0m0.006s user 0m0.001s sys 0m0.004s
В некоторых случаях вы можете записать вывод использования системного ресурса в файл, а не отображать его в терминале. Для этого используйте флаг -o, как показано ниже.
$ /usr/bin/time -o file.txt ls dir1 dir2 file1 file2 file.txt mcelog
Как вы можете видеть на выходе, утилита Time не отображает результат. Потому что мы записываем вывод в файл с именем file.txt. Давайте посмотрим на этот файл:
$ cat file.txt 0.00user 0.00system 0:00.00elapsed 66%CPU (0avgtext+0avgdata 2512maxresident)k 0inputs+0outputs (0major+106minor)pagefaults 0swaps
Когда вы используете флаг -o, если нет файла с именем «file.txt», он будет создавать и записывать вывод в него.
Если файл.txt уже присутствует, он перезапишет его содержимое.
Вы также можете добавить вывод в файл, а не переписывать его, используя флаг -a.
$ /usr/bin/time -a file.txt ls
Флаг -f позволяет пользователям управлять форматом вывода по своему усмотрению.
Скажем, например, следующая команда отображает вывод команды «ls» и показывает только пользователя, систему и общее время.
$ /usr/bin/time -f «t%E real,t%U user,t%S sys» ls dir1 dir2 file1 file2 mcelog 0:00.00 real, 0.00 user, 0.00 sys
Помните, что встроенная команда «time» не поддерживает все функции программы GNU time.
Для получения дополнительной информации о утилите времени GNU см. Справочные страницы.
$ man time
Пожалуйста, не спамьте и никого не оскорбляйте. Это поле для комментариев, а не спамбокс. Рекламные ссылки не индексируются!
Источник: itsecforu.ru
Вычисление времени работы алгоритма.
Вычислить точное время работы алгоритма оказывается невозможным. Это время помимо всего прочего зависит от характеристик реальной ЭВМ, на которой выполняется программа. Обычно время выполнения алгоритма считают приближенно. Более того, формулы для времени работы обычно содержат некоторые числовые константы, значение которых можно определить лишь опытным путем.
Даже такие оценки позволяют довольно часто выбрать один наилучший алгоритм. В других же случаях с помощью оценок времени работы можно отбросить заведомо медленные алгоритмы, а лучший из оставшихся выбрать с помощью измерения фактического времени работы программ.
Поясним сказанное на примерах. Пусть нужно выполнять некоторую обработку последовательности из n чисел, где n может меняться (скажем, нужно найти минимальное из этих чисел).
Пусть у нас есть две программы для решения задачи, времена работы которых приблизительно равны C1n и C2n 2 , где C1 и C2 – константы, не зависящие от n. Ясно, что при больших n первая программа будет работать быстрее. Скорее всего, при малых n она будет работать медленнее (именно так обычно бывает в практических случаях), а это означает, что C1 > C2. Пусть C1 в 5 раз больше C2. Сравнив выражения для времен работы C1n=5C2n и C2n 2 , можно увидеть, что при n> 5 время работы первой программы меньше, а при n< 5 быстрее вторая программа. Разумеется, ввиду приближенности оценок времени граничное значение n=5 тоже устанавливается приближенно.
Из наших гипотетических рассмотрений следуют два вывода. Первый: даже приближенные оценки «с точностью до константы» могут оказаться полезными при сравнении алгоритмов. Второй: обычно нельзя сказать, что какой-то один алгоритм решения задачи всегда самый быстрый. Некоторый алгоритм может превосходить другой для какого-то одного набора исходных данных и уступать ему для другого набора.
Остановимся на вопросе о выборе такой характеристики исходных данных, которая определяла бы время работы программы. Эта характеристика называется размером задачи. Для разных задач на время решения влияют разные свойства исходных данных.
Так, для задач типа поиска минимума или упорядочивания заданных чисел, где каждое число рассматривается как единое целое, размером задачи является количество исходных чисел. Для задачи разложения на простые сомножители размером естественно считать величину числа. Выбор размера задачи основан на некотором, хотя бы общем представлении об алгоритме решения. Обратимся к задаче вычисления 2 n . Учитывая, что возведение в степень будет выполняться путем последовательного умножения, выберем в качестве размера показатель степени N. Другим возможным кандидатом на роль размера является число цифр в результате. В нашей задаче число цифр в числе 2 n практически пропорционально N, поэтому оба размера эквиваленты.
Следующий важный момент при оценке времени работы – отыскание тех частей программы, выполнение которых занимает основную долю всего времени работы. Известен экспериментальный факт, справедливый для подавляющего большинства программ: основная часть времени работы тратится на выполнение очень небольшой части текста программы. Такая часть программы называется внутренним циклом. Так как с самого начала мы требуем приближенной оценки времени работы, поэтому всей остальной частью программы можно пренебречь.
Если программа представляет собой несколько вложенных друг в друга циклов, то внутренний цикл найти легко. Действительно, чаще всего будут выполняться те части программы, которые принадлежат всем циклам, а это как раз циклы, лежащие внутри всех остальных и не содержащие внутри себя других циклов. Это наблюдение оправдывает название «внутренний цикл» для наиболее часто выполняемых частей программы.
Если имеется несколько циклов, не содержащих внутри себя других, следует вычислить число повторений каждого из них. Если число повторений одного цикла окажется много больше, чем других, то временем работы этих других циклов можно пренебречь, в противном случае в окончательной формуле для времени работы придется учесть времена выполнения нескольких циклов. Число повторений цикла типа For определяется по следующей формуле:
Для цикла For I: =A to B
Число повторений равно B-A+1, если B³ A-1 (1)
Для цикла For I: =A downto B
В формуле следует поменять местами A и В.
Эта формула справедлива, если программа приступает к выполнению цикла всего один раз. Рассмотрим, как быть, если этот цикл вложен в другой и его выполнение повторяется много раз. Договоримся о терминологии. Когда нам понадобиться выяснить число повторений инструкций внутри цикла, будем называть это число числом выполнений тела цикла.
Число выполнений заголовка цикла – это сколько раз начинает выполняться весь цикл. Рассмотренная формула дает не что иное, как число выполнений тела цикла при однократном выполнении его заголовка. Если рассматриваемый цикл вложен в другой, то его заголовок будет выполняться многократно, и, чтобы найти общее число выполнений тела, следует просуммировать числа, даваемые рассмотренной формулой, при всех выполнениях заголовка цикла. В качестве простого примера применения этой формулы проанализируем следующий фрагмент программы:
For J: =1 To N Do Begin (*Цикл 1*)
For K: =1 To M Do Тело цикла 2;
For J: =1 Downto N Do Тело цикла 3;
Тела циклов 2 и 3 не содержат циклов, M и N – некоторые достаточно большие константы. Оценим число повторений циклов 2 и 3. оба они вложены в цикл 1, число повторений которого легко находится по формуле; оно равно N-1+1=N. При каждом из этих повторений тело цикла 2 выполняется M-1+1=M раз. Поскольку M – константа, общее число повторений цикла 2 равно N2=N*M.
Тело цикла 3 выполняется N-J+1 раз при каждом выполнении тела цикла 1. это число в отличие от M меняется при выполнении цикла 1; поэтому нельзя просто перемножить два числа: необходимо суммировать все числа выполнений тела цикла 3. заметим, что при выполнении цикла 1 переменная J принимает все значения от 1 до N (именно это записано в заголовке цикла 1). Таким образом, общее число выполнений тела цикла 3 равно N3= . Эта сумма арифметической прогрессии; она равна (N+1)*N/2. так как время вычисляется приближенно, то, пренебрегая 1 по сравнению с N, несколько упростим формулу: N3 приближенно равно N 2 /2.
Сравнивая N2 и N3, нельзя заключить, что одно их этих чисел значительно превосходит другое. Напротив, при некоторых M и N они будут одного порядка. Например, если M=N, то N2 примерно в два раза больше N3. поэтому в формулу для времени работы придется включить два слагаемых, отвечающих обоим циклам. Считая времена однократного выполнения тел циклов примерно постоянными и обозначив их T2 и T3, получим следующую приближенную формулу для общего времени работы: T=M*V+(N 2 /2)*T3.
Если времена выполнения тел циклов нельзя считать постоянными (например, когда в них есть условные инструкции или вызовы процедур), нужно сначала проанализировать времена выполнения тел, а затем просуммировать их (вместо умножения постоянного времени на число повторений).
Более детальную информацию о времени работы можно получить по результатам измерения фактического времени работы программы для различных исходных данных. С помощью этих экспериментальных данных можно оценить неизвестные постоянные, входящие в формулу (в нашем случае T2 и T3).
Источник: lektsia.com