Измерить время исполнения кода на C/C++ с помощью функции clock()
Доброго времени суток! Представьте, вы написали очень крутую программу, она решает поставленную задачу, алгоритм отточен до мельчайших деталей, код отрефакторен так, что сам господь улыбнется при его чтении, все отлично! Вы пришли на работу(учебу, тусовку пограмистов) и всем его показали, и тут «Васек» спросит: «А быстро работает?». И тут вы понимаете свою ошибку! Не измерили скорость работы программы! Не потестировали с разной нагрузкой, и вообще, там может быть куча дыр связанных, которые покажутся только при стрессовой нагрузке.
Ладно, хватит. На самом деле, я просто хотел написать о том, как измерить скорость исполнения любого участка кода. Сделать это можно на любом языке программирования, каждый язык каким либо образом да сможет обратиться к системе и спросить текущее время в миллисекундах.
Я расскажу про C/C++ просто потому что именно на этих языках чаще всего измерял скорость работы кода, для самых разнообразных учебных задач. От сортировки пузырьком до топологической сортировки графов.
Специальный тип данных clock_t в C/C++
Это не что иное, как алиас(кличка, переименование) стандартного арифметического типа данных. В значение ставится количество процессорных тиков с момента его запуска. Получить это значение можно с помощью функции clock() из библиотеки . Для того, чтобы перевести количество тиков в секунды используется константа из той же библиотеки CLOCKS_PER_SEC . Просто делим и получаем ответ.
//Специальный тип данных из библиотеки time.h clock_t currentTime; //Берем текущее системное время currentTime = clock(); //Участок кода, который нужно измерить for(int i = 0; i < 9000; i++) < i *= i; >//Берем разницу currentTime = clock() - currentTime; //Переводим в секунды currentTime = (double)currentTime / CLOCKS_PER_SEC;
Как найти время работы программы на С++
У многих начинающих программистов рано или поздно возникает вопрос: «Как найти время работы программы?». В интернете много ответов на данный вопрос: написать свой мини-дебаггер, посчитать количество тактов и т. д. Самый простой вариант — это посчитать разницу между начальным временем и конечным. То есть, есть начальное значение времени, после которого объявлен фрагмент кода, время выполнения которого необходимо измерить. После фрагмента кода фиксируется ещё одно, конечное, значение времени. После чего, из конечного значения времени вычитаем начальное время и получим время, за которое выполнился измеряемый фрагмент кода или вся программа. Время работы программы необходимо найти для того, чтобы проверить, насколько эффективнее стал работать отдельный алгоритм или программа в целом! Как это сделать,смотрите ниже.
// Как найти время работы фрагмента кода? // заголовочный файл с прототипом функции clock() #include // . unsigned int start_time = clock(); // начальное время // здесь должен быть фрагмент кода, время выполнения которого нужно измерить unsigned int end_time = clock(); // конечное время unsigned int search_time = end_time - start_time; // искомое время
Для того, чтобы найти время работы программы, нужно воспользоваться функцией clock() . Прототип функции clock() находится в заголовочном файле , который нужно подключить, строка 4. Функция clock() возвращает значение времени в миллисекундах (1с = 1000млс). Причём отсчёт времени начинается с момента запуска программы. Если надо измерить работу всей программы, то в конце программы, перед оператором return 0; нужно запустить функцию clock() , которая покажет рабочее время. Для поиска времени работы фрагмента кода нужно найти разницу между конечным и начальным временем, как показано выше.
// Как найти время работы программы? // заголовочный файл с прототипом функции clock() #include // . // здесь должен быть код программы, время выполнения которой нужно измерить unsigned int end_time = clock(); // время работы программы
Разработаем программу, в которой с помощью функции clock() вычислим время работы программы. Программа ищет минимальное значение в массиве размером в 200000 элементов. Размер массива специально выбран большим, для того, чтобы было заметно, как работает программа. Так как числа генерируются случайно, то при каждом запуске получается новый случай, и время может не совпадать. К тому же, время выполнения программы зависит от того, насколько загружен компьютер и от того, какая у компьютера вычислительная мощность. На разных машинах по-разному будет затрачиваться время на выполнение программы, на более мощных компьютерах затрачиваемое время будет меньше и наоборот.
// runtime.cpp: определяет точку входа для консольного приложения. // Как найти время работы программы? #include "stdafx.h" #include #include using namespace std; int main(int argc, char* argv[]) < srand(time(0)); const int array_size = 200000; // размер одномерного массива int array1[array_size]; // объявление одномерного массива for (int counter = 0; counter < array_size; counter++) < array1[counter] = rand() % 50 - rand() % 50; // заполняем массив случайными значениями в диапазоне от -49 до 49 включительно cout int min = array1[0]; // переменная для хранения минимального значения for (int counter = 1; counter < array_size; counter++) < if ( min >array1[counter] ) // поиск минимального значения в одномерном массиве min = array1[counter]; > cout
// runtime.cpp: определяет точку входа для консольного приложения. // Как найти время работы программы? #include #include #include using namespace std; int main(int argc, char* argv[]) < srand(time(0)); const int array_size = 200000; // размер одномерного массива int array1[array_size]; // объявление одномерного массива for (int counter = 0; counter < array_size; counter++) < array1[counter] = rand() % 50 - rand() % 50; // заполняем массив случайными значениями в диапазоне от -49 до 49 включительно cout int min = array1[0]; // переменная для хранения минимального значения for (int counter = 1; counter < array_size; counter++) < if ( min >array1[counter] ) // поиск минимального значения в одномерном массиве min = array1[counter]; > cout
В строке 26 запускается функция clock() , которая скажет сколько потребовалось время программе. Разбирать алгоритм поиска не нужно, так как это совсем другая тема. Главное, нужно понять, как использовать функцию clock() , для поиска времени работы программы или отдельного фрагмента кода. А именно, в строке 26, после основного кода программы, но до оператора return 0; объявлена функция clock() , которая вернёт значение времени. Результат работы программы (см. Рисунок 1).
CppStudio.com
-13 4 -2 30 8 9 27 10 11 -14 -31 1 6 -16 38 31 38 -26 22 21 13 16 42 11 2 11 25 12 0 3 -7 -38 -8 -4 0 42 29 -27 -8 6 -24 12 -12 -5 27 -21 11 5 -28 33 -6 -27 19 8 -24 -4 20 -33 16 13 30 38 -3 25 -8 30 13 -19 -7 -19 12 11 -11 -14 -33 12 -5 -2 7 10 16 -14 -23 10 -10 4 -19 15 27 20 23 -5 34 12 19 -19 -13 30 -11 6 -7 -16 27 -11 -19 -9 26 -3 0 -7 41 -3 -31 10 2 -4 5 15 -37 6 -10 -10 25 -28 7 17 19 -38 15 12 -27 -48 6 36 -35 18 -17 -20 28 -13 -32 -27 7 38 16 1 25 -16 -10 5 -26 31 -15 8 22 13 6 -5 11 -31 -3 -31 10 8 -3 19 -43 8 -29 -21 -8 3 44 32 -5 9 -23 19 -6 3 6 -7 -9 23 -31 2 -19 -2 -3 -5 -5 36 12 -14 21 5 9 10 13 21 -21 12 12 14 18 -27 - 26 -6 -6 -46 7 12 -16 -24 -26 18 -1 9 2 15 -12 17 20 19 -6 0 -1 -16 11 26 -12 0 -28 12 -26 -2 23 -1 0 11 -13 -34 6 22 4 -35 37 15 -15 -26 31 25 -4 2 19 0 7 -21 26 -1 -13 37 28 -13 4 22 22 5 34 2 8 6 -15 -1 25 25 0 22 -17 3 -27 1 43 8 41 -25 12 -15 32 -14 -6 -2 24 22 -33 0 -31 32 17 -32 -22 22 -32 0 3 -24 7 2 40 -28 -39 24 -5 12 -1 -1 27 min = -49 runtime = 59.449 Для продолжения нажмите любую клавишу . . .
Рисунок 1 — Как найти время работы программы
На рисунке 1 видно, что время выполнения программы приблизительно равно 59 секунд. Даже если элементы массива неизменны, время всё равно будет немного отличаться при повторном запуске программы, так как некоторые ресурсы компьютера постоянно будут заняты, а значит, не доступны программе. Если Вы запустите эту программу у себя на компьютере, то время выполнения программы может быть совсем другим, так как наши машины не идентичны.
Время выполнения программы C++
Время выполнения программы на С++ можно узнать функцией clock(), возвращающей время прошедшее с запуска программы в миллисекундах.
#include // clock() #include // std::cout int main() < int sum = 0; // Результат вычислений for(int i = 0; i < 100000000; i++)< // Перебираем значения sum += i; // Вычисляем сумму значений >unsigned int end_time = clock(); // Время окончания вычислений std::cout
Если требуется узнать время выполнения блока кода, то нужно сохранить в переменную значение функции clock() перед выполнением блока и вычесть из значения clock() после выполнения.
#include // clock() #include // std::cout int main() < int sum = 0; // Результат вычислений unsigned int start_time = clock(); // Время начала вычислений for(int i = 0; i < 100000000; i++)< // Перебираем значения sum += i; // Вычисляем сумму значений >unsigned int end_time = clock(); // Время окончания вычислений std::cout
Понравилась страница?
Добавить в закладки
Или поделиться!
Замерить время работы функции на С++
Мне нужно замерить время выполнения фрагмента кода (можно функции) на С++. Я прочитал, что для этого используется clock() из модуля time.h (ctime) – она возвращает число таков, измеряемое процессором от начала выполнения программы.
Глобальная константа CLOCKS_PER_SEC хранит число тактов, выполняемое процессором в секунду. Соответственно, чтобы получить время работы программы в секундах достаточно результат работы функции разделить на эту константу:
clock() / CLOCKS_PER_SEC; Для определения времени работы фрагмента программы нужно определить моменты времени до фрагмента и после него, а затем – посчитать разницу. Однако следующий фрагмент кода работает не так, как мне хотелось бы:
#include #include int main() < clock_t start = clock(); getchar(); clock_t end = clock(); double seconds = (double)(end - start) / CLOCKS_PER_SEC; printf("The time: %f seconds\n", seconds); >
В данном случае я надеюсь получить время, которое пользователь тратит на нажатие клавиши, однако вне зависимости от того, как долго я жду – результат получается примерно одинаковый, а время очень маленьким (см. скриншот). Хотя, если вместо getchar я ставлю фрагмент кода, выполняющий какие-либо вычисления – выводится правдоподобный результат. Подскажите в чем проблема и как ее решить.
23.07.2016 в 10:52 #2971
Функция clock() возвращает количество тиков процессора, которое сделала именно ваша программа, т.е. если программа ожидает ввод данных пользователем, то она не работает (операционная система вытесняет процесс из очереди задач). Следовательно нельзя замерить время ожидания ввода при помощи функции clock() – хотя подход, который вы привели, идеально подходит если вы хотите сравнить два алгоритма, т.к. в этом случае меньшее влияние оказывает загруженность системы. Определить количество секунд, которое выполняется программа можно с помощью функции time() :
#include #include int main()
Время при этом сохраняет с типом данных time_t – это целое число секунд, прошедшее с 1 января 1970 года. Функция difftime вычисляет разницу двух моментов времени. С помощью такого подхода вы сможете замерить время работы части программы, однако результат будет в секундах.
26.07.2016 в 15:49 #2974
При помощи средств, появившихся в стандартной библиотеке С++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 . Реальное время лучше отражает потребляемый ресурс процессора, т.к. если текущий процесс простаивает на кластере (где выполняются сотни других приложений), то он вытесняется операционной системой и практически не загружает процессор.