Как найти время работы программы на С++
У многих начинающих программистов рано или поздно возникает вопрос: «Как найти время работы программы?». В интернете много ответов на данный вопрос: написать свой мини-дебаггер, посчитать количество тактов и т. д. Самый простой вариант — это посчитать разницу между начальным временем и конечным. То есть, есть начальное значение времени, после которого объявлен фрагмент кода, время выполнения которого необходимо измерить. После фрагмента кода фиксируется ещё одно, конечное, значение времени. После чего, из конечного значения времени вычитаем начальное время и получим время, за которое выполнился измеряемый фрагмент кода или вся программа. Время работы программы необходимо найти для того, чтобы проверить, насколько эффективнее стал работать отдельный алгоритм или программа в целом! Как это сделать,смотрите ниже.
// Как найти время работы фрагмента кода? // заголовочный файл с прототипом функции 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/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;
Время выполнения программы 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
Понравилась страница?
Добавить в закладки
Или поделиться!
Как измерить время выполнения операции в C#
уважаемые посетители блога, если Вам понравилась, то, пожалуйста, помогите автору с лечением. Подробности тут.
При разработке различных программ иногда бывает необходимо измерить точное время какой-либо операции, например, узнать сколько времени требуется на загрузку данных из файла, запись в базу данных и так далее. Сегодня мы рассмотрим то, как измерить время выполнения операции в C#, используя стандартные средства и возможности языка.
System. Diagnostics
Пространство имен System.Diagnostics содержит классы, позволяющие нашим приложениям взаимодействовать с журналами событий, системными процессами и счётчиками производительности. В числе прочего, это пространство имен содержит класс под названием Stopwatch , который можно в своих приложениях C# использовать для точного измерения затраченного времени. Именно об этом классе мы сегодня и поговорим.
Простой пример использования Stopwatch
Для начала, рассмотрим простой пример использования класса Stopwatch для измерения затраченного времени на выполнение операции.
namespace StopwatchExample < class Program < static void Main(string[] args) < //создаем объект Stopwatch stopwatch = new Stopwatch(); //засекаем время начала операции stopwatch.Start(); //выполняем какую-либо операцию for (int i = 0; i < 10001; i++) < Console.WriteLine(i); >//останавливаем счётчик stopwatch.Stop(); //смотрим сколько миллисекунд было затрачено на выполнение Console.WriteLine(stopwatch.ElapsedMilliseconds); > > >
Чтобы измерить время выполнения операции в C# нам необходимо выполнить несколько простых шагов:
- Создать объект класса Stopwatch ;
- Выполнить метод Start() для того, чтобы засечь время начала операции;
- Выполнить метод Stop() для того, чтобы засечь время окончания операции;
- Воспользоваться одним из свойств объекта для получения данных о затраченном на выполнение операции времени.
В примере использовано свойство ElapsedMilliseconds , которое позволяет получить количество миллисекунд, затраченных на выполнение операции. Рассмотрим какие ещё есть свойства и методы у класса Stopwatch .
Stopwatch
Свойства Stopwatch
Elapsed
Свойство Elapsed позволяет получить общее затраченное время, измеренное текущим экземпляром класса Stopwatch . Описание свойства выглядит следующим образом:
public TimeSpan Elapsed
Свойство возвращает объект типа TimeSpan — интервал времени, используя который, можно получить время выполнения операции в удобном для вас виде. Например,
//получаем объект TimeSpan TimeSpan ts = stopwatch.Elapsed; // Создаем строку, содержащую время выполнения операции. string elapsedTime = String.Format("::.", ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10); Console.WriteLine(elapsedTime);
ElapsedMilliseconds
Свойство ElapsedMilliseconds позволяет получить общее затраченное время, измеренное текущим экземпляром класса Stopwatch в миллисекундах. В примере использования класса Stopwatch выше продемонстрировано использование этого свойства.
Elapsed Ticks
Свойство Elapsed Ticks позволяет получить общее время выполнение операции в тактах таймера, измеренное текущим экземпляром Stopwatch . Такт — это наименьшая единица времени, которую Stopwatch может измерять таймер. В следующем примере показано использование свойства Elapsed Ticks для измерения времени, затраченного на преобразование строки в целое число типа int .
int num; //создаем объект Stopwatch stopwatch = new Stopwatch(); //засекаем время начала операции stopwatch.Start(); num = int.Parse("135"); //останавливаем счётчик stopwatch.Stop(); Console.WriteLine($"num = "); //смотрим сколько тактов было затрачено на выполнение Console.WriteLine(stopwatch.ElapsedTicks);
Результатом выполнения этого кода может быть вот такой вывод консоли:
Is Running
Свойство IsRunning позволяет получить значение типа bool , указывающее на то запущен ли в данный момент таймер Stopwatch .
Поля Stopwatch
Класс Stopwatch содержит два статических поля, позволяющих получить сведения о настройках таймера.
Frequency
Поле Frequency содержит частоту таймера в виде количества тактов в секунду.
public static readonly long Frequency;
Это поле удобно использовать вместе со свойством Elapsed Ticks для преобразования количества тактов в секунды. Например,
int num; long freq = Stopwatch.Frequency; //частота таймера Stopwatch stopwatch = new Stopwatch(); stopwatch.Start(); num = int.Parse("135"); //останавливаем счётчик stopwatch.Stop(); double sec = (double)stopwatch.ElapsedTicks / freq; //переводим такты в секунды Console.WriteLine($"num = \r\n Частота таймера такт/с \r\n Время в тактах \r\n Время в секундах ");
Обращу внимание только на то, как происходит перевод тактов в секунды. Учитывая особенности деления целых чисел в C#, для того, чтобы получить конкретное значение секунд нам потребовалось привести одно из значений (в данном случае значение свойства ElapsedTicks ) к типу double .
Is High Resolution
Свойство Is High Resolution указывает, зависит ли таймер Stopwatch от счетчика производительности высокого разрешения ( true ) или же использует класс DateTime ( false ).
public static readonly bool IsHighResolution;
Пример использования поля
class Program < static void Main(string[] args) < DisplayTimerProperties(); >public static void DisplayTimerProperties() < if (Stopwatch.IsHighResolution) < Console.WriteLine("Операции рассчитываются с использованием системного счетчика производительности с высоким разрешением."); >else < Console.WriteLine("Операции рассчитываются с использованием класса DateTime."); >long frequency = Stopwatch.Frequency; Console.WriteLine($" Частота таймера = "); long nanosecPerTick = (1000L * 1000L * 1000L) / frequency; Console.WriteLine($" Таймер работает с точностью до наносекунд"); > >
Вывод консоли будет иметь следующий вид:
Операции рассчитываются с использованием системного счетчика производительности с высоким разрешением.
Частота таймера = 10000000
Таймер работает с точностью до 100 наносекунд
Методы Stopwatch
Рассмотрим основные методы класса Stopwatch , которые мы можем использовать для измерения точного времени выполнения операции в C#.
Start и Stop
Метод Start() запускает или возобновляет работу таймера Stopwatch . В свою очередь, Stop() выполняет противоположную операцию — останавливает работу таймера. Использование этих методов продемонстрировано в самом первом примере из этой статьи.
Start New
Метод Start New() выполняет сразу несколько операций — он инициализирует новый экземпляр класса Stopwatch , обнуляет счётчик затраченного времени и запускает таймер. То есть, этот метод позволяет немного сократить исходный код программы. Например, код из первого примера можно было бы записать вот так:
Stopwatch stopwatch = Stopwatch.StartNew();//создаем и запускаем таймер for (int i = 0; i < 10001; i++) < Console.WriteLine(i); >//останавливаем счётчик stopwatch.Stop(); //смотрим сколько миллисекунд было затрачено на выполнение Console.WriteLine(stopwatch.ElapsedMilliseconds);
Reset
Метод Reset() останавливает измерение интервала времени и обнуляет счётчик затраченного времени. Использование Reset() позволяет избежать создания новых экземпляров Stopwatch для измерения времени, затраченного на выполнение нескольких операций в C#.
Stopwatch stopwatch = Stopwatch.StartNew();//создаем и запускаем таймер for (int i = 0; i < 100; i++) < Console.WriteLine(i); >//останавливаем счётчик stopwatch.Stop(); //смотрим сколько миллисекунд было затрачено на выполнение Console.WriteLine($"Первая операция "); stopwatch.Reset(); //сбросили счётчик stopwatch.Start(); //запустили счётчик for (int i = 0; i < 100; i++) < Console.WriteLine(i*i); >stopwatch.Stop(); //смотрим сколько миллисекунд было затрачено на выполнение Console.WriteLine($"Вторая операция ");
Restart
Метод Restart() останавливает измерение интервала времени, обнуляет затраченное время и повторно запускает таймер. Таким образом, предыдущий пример можно переписать следующим образом:
Stopwatch stopwatch = Stopwatch.StartNew();//создаем и запускаем таймер for (int i = 0; i < 100; i++) < Console.WriteLine(i); >//останавливаем счётчик stopwatch.Stop(); //смотрим сколько миллисекунд было затрачено на выполнение Console.WriteLine($"Первая операция "); stopwatch.Restart(); //перезапускаем счётчик for (int i = 0; i < 100; i++) < Console.WriteLine(i*i); >stopwatch.Stop(); //смотрим сколько миллисекунд было затрачено на выполнение Console.WriteLine($"Вторая операция ");
Итого
Класс Stopwatch из пространства имен System. Diagnostics C# позволяет измерить время выполнения операции с точностью до 100 наносекунд в зависимости от того, что используется для работы с интервалами времени — таймер высокого разрешения или же класс DateTime .
уважаемые посетители блога, если Вам понравилась, то, пожалуйста, помогите автору с лечением. Подробности тут.