Как узнать время выполнения алгоритма
Мне нужно сравнить несколько алгоритмов сортировки.
Но таким способом как у меня, дает очень маленькие значения .
дл массива int — ов, размером в [2000] было 0,016 для массива [20000] что то около 0,745 . это нормально ? есть еще какие то методы ? .
вот мой вариант
clock_t time; time = clock(); // КОД time = clock() - time; cout "Time: "; printf("%f", (double)time / CLOCKS_PER_SEC);
как узнать время работы программы решения алгоритма
Добрый вечер! Подскажите, пожалуйста, как сделать так, чтобы программа выводила на экран время.
Как узнать кодировку вывода в консоль во время выполнения программы?
Привет всем! Я новичок, и возникла идея написать консольное приложение для Windows которое.
Как узнать тип шаблонного класса во время выполнения программы?
Тоесть: имеем класс list<int> или list<double>, и как узнать какой это тип? Ну int или double?
Время выполнения алгоритма
#include <iostream> #include <cstdlib> #include <time.h> using namespace std; void.
#include double start = GetTickCount(); ///// сортирока double finish = GetTickCount(); finish - start; // время сортировки в принципе тоже самое .
и почему то когда запускаю несколько раз, выдает знаеение то ноль, то 15, то 16
а для сортировки вставками, постоянно ноль
скажите пожалуйста, каким компилятором вы пользуетесь.
Добавлено через 15 минут
вобщем для g++:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
#include using namespace std; static inline unsigned long long int tick() { unsigned long long int d; __asm__ __volatile__ ("rdtsc" : "=A" (d) ); return d; } int main() { unsigned long long int a = 0; unsigned long long int b = 0; a=tick(); //сортировка b=tick(); coutb-aendl; return 0; } (b-a) — количество процессорных тактов.
1 2 3 4 5 6 7 8 9 10 11 12 13
// rdtsc.cpp // processor: x86, x64 #include #include #pragma intrinsic(__rdtsc) int main() { unsigned __int64 i; i = __rdtsc(); printf_s("%I64d ticks\n", i); }
Сообщение от Vladimir. 
1 2 3 4 5 6 7 8 9 10 11 12 13
// rdtsc.cpp // processor: x86, x64 #include #include #pragma intrinsic(__rdtsc) int main() { unsigned __int64 i; i = __rdtsc(); printf_s("%I64d ticks\n", i); }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
#include #include #pragma intrinsic(__rdtsc) unsigned __int64 tick(){ return (__rdtsc()); } int main() { unsigned __int64 a,b; a = tick(); // проверяемый код b = tick(); std::coutb-astd::endl; } Сообщение от Vladimir.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
#include #include #pragma intrinsic(__rdtsc) unsigned __int64 tick(){ return (__rdtsc()); } int main() { unsigned __int64 a,b; a = tick(); // проверяемый код b = tick(); std::coutb-astd::endl; } а код из шестого сообщения работает? (как Вы поняли у меня VS нет, поэтому проверить я не могу)
и «не работает» или «не компилируется»? если не копилируется — что в сообщении об ошибке?
Попробуйте структуру SYSTEMTIME.
Сортировки
Сообщение от igorio4eg
GetLocalTime(&st1); for(int i =0;i5000;i++) Function(); GetLocalTime(&st2);
double T1 = (double)(st1.wMinute*60*1000 + st1.wSecond*1000 + st1.wMilliseconds); //вычисляем время double T2 = (double)(st2.wMinute*60*1000 + st2.wSecond*1000 + st2.wMilliseconds); cout endl RUS("Для size = ") size2[j] " \n" ; cout RUS("время выполнения функции: "); cout (T2 - T1)/5000 RUS(" Миллисекунд") endl;
1 2 3 4 5 6 7 8 9 10 11 12 13 14
#include #include #pragma intrinsic(__rdtsc) int main() { unsigned __int64 i, m, res; i = __rdtsc(); // код m = __rdtsc(); res = m - i; printf_s("%I64d ticks\n", res); } Хорошо, хотя теперь у меня возникли вопросы. Ладно, доберусь до машины с вс проверю.
Учитывайте, что есть тонкости с dts вроде общей загруженности проца другими программами и верной работы на некоторых многоядерных машинах.
зы: а вобще RUSya82 насчёт многоразового запуска сортировки прав.
Сообщение от RUSya82
Попробуйте структуру SYSTEMTIME.
Сортировки
Эта проблема решается запуском функции сортировки много много раз, с определением среднего времени.
GetLocalTime(&st1); for(int i =0;i5000;i++) Function(); GetLocalTime(&st2);
double T1 = (double)(st1.wMinute*60*1000 + st1.wSecond*1000 + st1.wMilliseconds); //вычисляем время double T2 = (double)(st2.wMinute*60*1000 + st2.wSecond*1000 + st2.wMilliseconds); cout endl RUS("Для size = ") size2[j] " \n" ; cout RUS("время выполнения функции: "); cout (T2 - T1)/5000 RUS(" Миллисекунд") endl;
Один.
Объявите в начале функции main две переменные типа структуры SYSTEMTIME, в например st1 и st2.
Функция GetLocalTime(&st1) записывает в st1 время на момент вызова.
Далее Вы вызываете требуемую функцию сортировки 5000 раз(это число произвольно).
Далее GetLocalTime(&st2) записывает в st2 время окончания сортировок.
Вторая часть выводит на экран время в миллисекундах. Просто разница во времени делится на 5000, чтобы получить среднее время, на работу одной функции.
З.Ы. подключите windows.h
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
#include #include /* int main() unsigned int x = 0xFFFFFFFF; // some code for calculate time while(--x != 0); printf("%g\n", (double)clock() / CLOCKS_PER_SEC); return 0; > */ int main() { unsigned int x = 0xFFFFFFFF; time_t beg, end; time(&beg); // some code for calculate time while(--x != 0); time(&end); printf("%g\n", difftime(end, beg)); return 0; } Замерить время работы функции на С++
Мне нужно замерить время выполнения фрагмента кода (можно функции) на С++. Я прочитал, что для этого используется clock() из модуля time.h (ctime) — она возвращает число таков, измеряемое процессором от начала выполнения программы.
Глобальная константа CLOCKS_PER_SEC хранит число тактов, выполняемое процессором в секунду. Соответственно, чтобы получить время работы программы в секундах достаточно результат работы функции разделить на эту константу:
clock() / CLOCKS_PER_SEC; Для определения времени работы фрагмента программы нужно определить моменты времени до фрагмента и после него, а затем — посчитать разницу. Однако следующий фрагмент кода работает не так, как мне хотелось бы:
В данном случае я надеюсь получить время, которое пользователь тратит на нажатие клавиши, однако вне зависимости от того, как долго я жду — результат получается примерно одинаковый, а время очень маленьким (см. скриншот). Хотя, если вместо getchar я ставлю фрагмент кода, выполняющий какие-либо вычисления — выводится правдоподобный результат. Подскажите в чем проблема и как ее решить.
Функция clock() возвращает количество тиков процессора, которое сделала именно ваша программа, т.е. если программа ожидает ввод данных пользователем, то она не работает (операционная система вытесняет процесс из очереди задач). Следовательно нельзя замерить время ожидания ввода при помощи функции clock() — хотя подход, который вы привели, идеально подходит если вы хотите сравнить два алгоритма, т.к. в этом случае меньшее влияние оказывает загруженность системы. Определить количество секунд, которое выполняется программа можно с помощью функции time() :
Время при этом сохраняет с типом данных time_t — это целое число секунд, прошедшее с 1 января 1970 года. Функция difftime вычисляет разницу двух моментов времени. С помощью такого подхода вы сможете замерить время работы части программы, однако результат будет в секундах.
При помощи средств, появившихся в стандартной библиотеке С++11 можно получить более высокую точность измерения и замерить время независимо от системных часов (с помощью так называемых стабильных часов). Обзор библиотеки chrono. Следующий фрагмент кода выполняет замер времени с использованием стабильных часов:
#include #include int main() < auto begin = std::chrono::steady_clock::now(); getchar(); auto end = std::chrono::steady_clock::now(); auto elapsed_ms = std::chrono::duration_cast(end - begin); std::cout
Функция std::chrono::duration_cast преобразует объект типа time_point во временной интервал ( duration ), при этом в качестве параметра шаблона передается промежуток времени в виде долей секунды (в данном случае миллисекунды). Использование библиотеки chrono — лучший способ если нужно фактическое замерить время выполнения программы (в отличии функции time() , модуля time.h она позволяет получить время в миллисекундах и даже наносекундах). Однако если программа работает на многопроцессорной системе и часто ожидает какие-либо данные (не только пользовательский ввод, но и данных от других потоков/процессов) — то больший интерес может представлять реальное время выполнения, возвращаемое функцией clock() модуля time.h . Реальное время лучше отражает потребляемый ресурс процессора, т.к. если текущий процесс простаивает на кластере (где выполняются сотни других приложений), то он вытесняется операционной системой и практически не загружает процессор.
Найдите время выполнения программы на C
В этом посте будет обсуждаться, как найти время выполнения программы C в средах Windows и Linux.
Существует четыре широко используемых метода определения времени выполнения программы на C:
1. Использование clock() функция
Мы можем использовать clock() функция, предоставляемая заголовочный файл для расчета времени ЦП, потребляемого задачей в приложении C. Он возвращает clock_t type, в котором хранится общее количество тактов часов.
Чтобы вычислить общее количество прошедших секунд, нам нужно разделить общее количество прошедших тактов часов на CLOCKS_PER_SEC макрос (также присутствует в ) как показано ниже:
Выход (может варьироваться):
The elapsed time is 0.000014 seconds
Обратите внимание, что clock() Функция не возвращает фактическое количество прошедшего времени, а возвращает количество времени, которое потребовалось базовой операционной системе для запуска процесса. Другими словами, фактическое время настенных часов может быть намного больше.
2. Использование time() функция
The заголовок также предоставляет time() функция, которая возвращает общее количество секунд, прошедших с начала Эпохи (00:00:00 UTC, 1 января 1970 г.). Он принимает указатель на time_t в качестве аргумента, который обычно передается как NULL и возвращает time_t тип. Если аргумент не NULL , то возвращаемое значение также сохраняется в памяти, на которую указывает аргумент.
Его использование аналогично clock() функцию, как показано ниже:
Как замерить длительность выполнения кода?
Как с точностью до микросекунд замерить время выполнения функции?
Товарищи, подскажите, как с точностью до микросекунд замерить время выполнения некоторой функции?
Замерить время выполнения
Здравствуйте.Задача такая есть сайт и есть верхний тул бар, при нажатие на одну из кнопок.
Замерить скорость выполнения алгоритма
Как в Pascal ABC измерить скорость выполнения всего кода либо отдельного участка?
Замерить время выполнения потока
Здравствуйте, нужно узнать за сколько времени выполнится поток? При последовательном исполнении.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
#include #include #include int main() { clock_t start, end; start = clock(); /* Код, который время выполнения которого нужно измерить */ /* */ end = clock(); printf("The above code block was executed in %.4f second(s)\n", ((double) end - start) / ((double) CLOCKS_PER_SEC)); return 0; } 
Сообщение от xxbesoxx
м?) выше приведенный код замеряет время выполнения участка кода..
например этот не очень красивый код:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64
#include #include #include void sort(int * arr, int n); void show(int * arr, int n); int main() { clock_t start, end; int n; int * arr; scanf("%d",&n); // Ввод размера массива arr = (int *)malloc(n * sizeof(int)); // Выделяем память под элементы srand(time(NULL)); for(int i=0; in; i++) // Рандомный ввод массива arr[i] = rand()%50; show(arr,n); printf("\n---------------------\n"); start = clock(); sort(arr,n); // Замеряем данный кусок (сортировка) end = clock(); show(arr,n); printf("\nThe above code block was executed in %.4f second(s)\n", ((double) end - start) / ((double) CLOCKS_PER_SEC)); free(arr); // Чистим память return 0; } // ---------------------------------- // void show(int *arr, int n) { for(int i=0; in; i++) printf("%d ",arr[i]); } void sort(int * arr, int n) { int temp; for(int j=0; jn; j++) for(int i=0; in; i++) { if(arr[i] > arr[i+1]) { temp = arr[i]; arr[i] = arr[i+1]; arr[i+1] = temp; } } }