Некоторые сведения относятся к предварительной версии продукта, в которую до выпуска могут быть внесены существенные изменения. Майкрософт не предоставляет никаких гарантий, явных или подразумеваемых, относительно приведенных здесь сведений.
Предоставляет набор методов и свойств, которые можно использовать для точного измерения затраченного времени.
public ref class Stopwatch
public class Stopwatch
type Stopwatch = class
Public Class Stopwatch
Наследование
Примеры
В следующем примере показано, как использовать Stopwatch класс для определения времени выполнения приложения.
using System; using System.Diagnostics; using System.Threading; class Program < static void Main(string[] args) < Stopwatch stopWatch = new Stopwatch(); stopWatch.Start(); Thread.Sleep(10000); stopWatch.Stop(); // Get the elapsed time as a TimeSpan value. TimeSpan ts = stopWatch.Elapsed; // Format and display the TimeSpan value. string elapsedTime = String.Format(«::.», ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10); Console.WriteLine(«RunTime » + elapsedTime); > >
Imports System.Diagnostics Imports System.Threading Class Program Shared Sub Main(ByVal args() As String) Dim stopWatch As New Stopwatch() stopWatch.Start() Thread.Sleep(10000) stopWatch.Stop() ‘ Get the elapsed time as a TimeSpan value. Dim ts As TimeSpan = stopWatch.Elapsed ‘ Format and display the TimeSpan value. Dim elapsedTime As String = String.Format(«::.», ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10) Console.WriteLine( «RunTime » + elapsedTime) End Sub End Class
Время в C++
В следующем примере показано использование класса для Stopwatch вычисления данных о производительности.
#using using namespace System; using namespace System::Diagnostics; void DisplayTimerProperties() < // Display the timer frequency and resolution. if ( Stopwatch::IsHighResolution ) < Console::WriteLine( «Operations timed using the system’s high-resolution performance counter.» ); >else < Console::WriteLine( «Operations timed using the DateTime class.» ); >Int64 frequency = Stopwatch::Frequency; Console::WriteLine( » Timer frequency in ticks per second = «, frequency ); Int64 nanosecPerTick = (1000L * 1000L * 1000L) / frequency; Console::WriteLine( » Timer is accurate within nanoseconds», nanosecPerTick ); > void TimeOperations() < Int64 nanosecPerTick = (1000L * 1000L * 1000L) / Stopwatch::Frequency; const long numIterations = 10000; // Define the operation title names. array^operationNames = ; // Time four different implementations for parsing // an integer from a string. for ( int operation = 0; operation catch ( FormatException^ ) < inputNum = 0; >// Stop the timer, and save the // elapsed ticks for the operation. timePerParse->Stop(); ticksThisTime = timePerParse->ElapsedTicks; break; case 1: // Parse a valid integer using // the TryParse statement. // Start a new stopwatch timer. timePerParse = Stopwatch::StartNew(); if ( !Int32::TryParse( «0», inputNum ) ) < inputNum = 0; >// Stop the timer, and save the // elapsed ticks for the operation. timePerParse->Stop(); ticksThisTime = timePerParse->ElapsedTicks; break; case 2: // Parse an invalid value using // a try-catch statement. // Start a new stopwatch timer. timePerParse = Stopwatch::StartNew(); try < inputNum = Int32::Parse( «a» ); >catch ( FormatException^ ) < inputNum = 0; >// Stop the timer, and save the // elapsed ticks for the operation. timePerParse->Stop(); ticksThisTime = timePerParse->ElapsedTicks; break; case 3: // Parse an invalid value using // the TryParse statement. // Start a new stopwatch timer. timePerParse = Stopwatch::StartNew(); if ( !Int32::TryParse( «a», inputNum ) ) < inputNum = 0; >// Stop the timer, and save the // elapsed ticks for the operation. timePerParse->Stop(); ticksThisTime = timePerParse->ElapsedTicks; break; default: break; > // Skip over the time for the first operation, // just in case it caused a one-time // performance hit. if ( i == 0 ) < time10kOperations->Reset(); time10kOperations->Start(); > else < // Update operation statistics // for iterations 1-10001. if ( maxTicks < ticksThisTime ) < indexSlowest = i; maxTicks = ticksThisTime; >if ( minTicks > ticksThisTime ) < indexFastest = i; minTicks = ticksThisTime; >numTicks += ticksThisTime; if ( numTicks < ticksThisTime ) < // Keep track of rollovers. numRollovers++; >> > // Display the statistics for 10000 iterations. time10kOperations->Stop(); milliSec = time10kOperations->ElapsedMilliseconds; Console::WriteLine(); Console::WriteLine( » Summary:», operationNames[ operation ] ); Console::WriteLine( » Slowest time: #/ = ticks», indexSlowest, numIterations, maxTicks ); Console::WriteLine( » Fastest time: #/ = ticks», indexFastest, numIterations, minTicks ); Console::WriteLine( » Average time: ticks = nanoseconds», numTicks / numIterations, (numTicks * nanosecPerTick) / numIterations ); Console::WriteLine( » Total time looping through operations: milliseconds», numIterations, milliSec ); > > int main()
using System; using System.Diagnostics; namespace StopWatchSample < class OperationsTimer < public static void Main() < DisplayTimerProperties(); Console.WriteLine(); Console.WriteLine(«Press the Enter key to begin:»); Console.ReadLine(); Console.WriteLine(); TimeOperations(); >public static void DisplayTimerProperties() < // Display the timer frequency and resolution. if (Stopwatch.IsHighResolution) < Console.WriteLine(«Operations timed using the system’s high-resolution performance counter.»); >else < Console.WriteLine(«Operations timed using the DateTime class.»); >long frequency = Stopwatch.Frequency; Console.WriteLine(» Timer frequency in ticks per second = «, frequency); long nanosecPerTick = (1000L*1000L*1000L) / frequency; Console.WriteLine(» Timer is accurate within nanoseconds», nanosecPerTick); > private static void TimeOperations() < long nanosecPerTick = (1000L*1000L*1000L) / Stopwatch.Frequency; const long numIterations = 10000; // Define the operation title names.
String [] operationNames = ; // Time four different implementations for parsing // an integer from a string. for (int operation = 0; operation catch (FormatException) < inputNum = 0; >// Stop the timer, and save the // elapsed ticks for the operation. timePerParse.Stop(); ticksThisTime = timePerParse.ElapsedTicks; break; case 1: // Parse a valid integer using // the TryParse statement. // Start a new stopwatch timer. timePerParse = Stopwatch.StartNew(); if (!Int32.TryParse(«0», out inputNum)) < inputNum = 0; >// Stop the timer, and save the // elapsed ticks for the operation. timePerParse.Stop(); ticksThisTime = timePerParse.ElapsedTicks; break; case 2: // Parse an invalid value using // a try-catch statement. // Start a new stopwatch timer. timePerParse = Stopwatch.StartNew(); try < inputNum = Int32.Parse(«a»); >catch (FormatException) < inputNum = 0; >// Stop the timer, and save the // elapsed ticks for the operation. timePerParse.Stop(); ticksThisTime = timePerParse.ElapsedTicks; break; case 3: // Parse an invalid value using // the TryParse statement. // Start a new stopwatch timer. timePerParse = Stopwatch.StartNew(); if (!Int32.TryParse(«a», out inputNum)) < inputNum = 0; >// Stop the timer, and save the // elapsed ticks for the operation. timePerParse.Stop(); ticksThisTime = timePerParse.ElapsedTicks; break; default: break; > // Skip over the time for the first operation, // just in case it caused a one-time // performance hit. if (i == 0) < time10kOperations.Reset(); time10kOperations.Start(); >else < // Update operation statistics // for iterations 1-10000. if (maxTicks < ticksThisTime) < indexSlowest = i; maxTicks = ticksThisTime; >if (minTicks > ticksThisTime) < indexFastest = i; minTicks = ticksThisTime; >numTicks += ticksThisTime; if (numTicks < ticksThisTime) < // Keep track of rollovers. numRollovers ++; >> > // Display the statistics for 10000 iterations. time10kOperations.Stop(); milliSec = time10kOperations.ElapsedMilliseconds; Console.WriteLine(); Console.WriteLine(» Summary:», operationNames[operation]); Console.WriteLine(» Slowest time: #/ = ticks», indexSlowest, numIterations, maxTicks); Console.WriteLine(» Fastest time: #/ = ticks», indexFastest, numIterations, minTicks); Console.WriteLine(» Average time: ticks = nanoseconds», numTicks / numIterations, (numTicks * nanosecPerTick) / numIterations ); Console.WriteLine(» Total time looping through operations: milliseconds», numIterations, milliSec); > > > >
Imports System.Diagnostics Class OperationsTimer Public Shared Sub Main() DisplayTimerProperties() Console.WriteLine() Console.WriteLine(«Press the Enter key to begin:») Console.ReadLine() Console.WriteLine() TimeOperations() End Sub Public Shared Sub DisplayTimerProperties() ‘ Display the timer frequency and resolution.
КАК ИЗМЕРИТЬ ВРЕМЯ ВЫПОЛНЕНИЯ ПРОГРАММЫ, КОДА, МЕТОДА, ФУНКЦИИ, ЗАПРОСА | C# STOPWATCH | C# ПЛЮШКИ
If Stopwatch.IsHighResolution Then Console.WriteLine(«Operations timed using the system’s high-resolution performance counter.») Else Console.WriteLine(«Operations timed using the DateTime class.») End If Dim frequency As Long = Stopwatch.Frequency Console.WriteLine(» Timer frequency in ticks per second = «, frequency) Dim nanosecPerTick As Long = 1000000000 / frequency Console.WriteLine(» Timer is accurate within nanoseconds», nanosecPerTick) End Sub Private Shared Sub TimeOperations() Dim nanosecPerTick As Long = 1000000000 / Stopwatch.Frequency Const numIterations As Long = 10000 ‘ Define the operation title names. Dim operationNames As String() = _ ‘ Time four different implementations for parsing ‘ an integer from a string.
Dim operation As Integer For operation = 0 To 3 ‘ Define variables for operation statistics. Dim numTicks As Long = 0 Dim numRollovers As Long = 0 Dim maxTicks As Long = 0 Dim minTicks As Long = Int64.MaxValue Dim indexFastest As Integer = — 1 Dim indexSlowest As Integer = — 1 Dim milliSec As Long = 0 Dim time10kOperations As Stopwatch = Stopwatch.StartNew() ‘ Run the current operation 10001 times. ‘ The first execution time will be tossed ‘ out, since it can skew the average time.
Dim i As Integer For i = 0 To numIterations Dim ticksThisTime As Long = 0 Dim inputNum As Integer Dim timePerParse As Stopwatch Select Case operation Case 0 ‘ Parse a valid integer using ‘ a try-catch statement. ‘ Start a new stopwatch timer. timePerParse = Stopwatch.StartNew() Try inputNum = Int32.Parse(«0») Catch e As FormatException inputNum = 0 End Try ‘ Stop the timer, and save the ‘ elapsed ticks for the operation. timePerParse.Stop() ticksThisTime = timePerParse.ElapsedTicks Case 1 ‘ Parse a valid integer using ‘ the TryParse statement. ‘ Start a new stopwatch timer. timePerParse = Stopwatch.StartNew() If Not Int32.TryParse(«0», inputNum) Then inputNum = 0 End If ‘ Stop the timer, and save the ‘ elapsed ticks for the operation. timePerParse.Stop() ticksThisTime = timePerParse.ElapsedTicks Case 2 ‘ Parse an invalid value using ‘ a try-catch statement. ‘ Start a new stopwatch timer. timePerParse = Stopwatch.StartNew() Try inputNum = Int32.Parse(«a») Catch e As FormatException inputNum = 0 End Try ‘ Stop the timer, and save the ‘ elapsed ticks for the operation. timePerParse.Stop() ticksThisTime = timePerParse.ElapsedTicks Case 3 ‘ Parse an invalid value using ‘ the TryParse statement. ‘ Start a new stopwatch timer. timePerParse = Stopwatch.StartNew() If Not Int32.TryParse(«a», inputNum) Then inputNum = 0 End If ‘ Stop the timer, and save the ‘ elapsed ticks for the operation. timePerParse.Stop() ticksThisTime = timePerParse.ElapsedTicks Case Else End Select ‘ Skip over the time for the first operation, ‘ just in case it caused a one-time ‘ performance hit. If i = 0 Then time10kOperations.Reset() time10kOperations.Start() Else ‘ Update operation statistics ‘ for iterations 1-10001. If maxTicks < ticksThisTime Then indexSlowest = i maxTicks = ticksThisTime End If If minTicks >ticksThisTime Then indexFastest = i minTicks = ticksThisTime End If numTicks += ticksThisTime If numTicks < ticksThisTime Then ‘ Keep track of rollovers. numRollovers += 1 End If End If Next i ‘ Display the statistics for 10000 iterations. time10kOperations.Stop() milliSec = time10kOperations.ElapsedMilliseconds Console.WriteLine() Console.WriteLine(«Summary:», operationNames(operation)) Console.WriteLine(» Slowest time: #/ = ticks», _ indexSlowest, numIterations, maxTicks) Console.WriteLine(» Fastest time: #/ = ticks», _ indexFastest, numIterations, minTicks) Console.WriteLine(» Average time: ticks = nanoseconds», _ numTicks / numIterations, numTicks * nanosecPerTick / numIterations) Console.WriteLine(» Total time looping through operations: milliseconds», _ numIterations, milliSec) Next operation End Sub End Class
Комментарии
Экземпляр Stopwatch может измерять затраченное время для одного интервала или общее количество затраченного времени за несколько интервалов. В типичном Stopwatch сценарии вызывается Start метод , затем в конечном итоге вызывается Stop метод и проверяется затраченное время с помощью Elapsed свойства .
Экземпляр Stopwatch запущен или остановлен; используйте для IsRunning определения текущего Stopwatchсостояния . Используйте , Start чтобы начать измерение затраченного времени; используйте , Stop чтобы остановить измерение затраченного времени. Запрос значения затраченного времени с помощью свойств Elapsed, ElapsedMillisecondsили ElapsedTicks. Вы можете запросить свойства затраченного времени во время выполнения или остановки экземпляра. Свойства затраченного времени постоянно увеличиваются во время Stopwatch выполнения . Они остаются постоянными при остановке экземпляра.
По умолчанию значение затраченного времени экземпляра Stopwatch равно общему значению всех измеренных интервалов времени. Каждый вызов начинает Start подсчет в совокупное затраченное время; каждый вызов завершает Stop измерение текущего интервала и замораживает совокупное значение затраченного времени. Используйте метод для Reset очистки совокупного затраченного времени в существующем Stopwatch экземпляре.
Измерение Stopwatch затраченного времени путем подсчета тактов таймера в базовом механизме таймера. Если установленное оборудование и операционная система поддерживают счетчик производительности с высоким разрешением Stopwatch , класс использует этот счетчик для измерения затраченного времени. Stopwatch В противном случае класс использует системный таймер для измерения затраченного времени. Frequency Используйте поля и IsHighResolution для определения точности и разрешения Stopwatch реализации времени.
Класс Stopwatch помогает управлять счетчиками производительности, связанными с временем, в управляемом коде. В частности, Frequency поле и GetTimestamp метод можно использовать вместо неуправляемых API QueryPerformanceFrequency Windows и QueryPerformanceCounter .
На многопроцессорном компьютере не имеет значения, на каком процессоре выполняется поток. Однако из-за ошибок в BIOS или на уровне аппаратной абстракции (HAL) можно получить разные результаты по времени на разных процессорах. Чтобы указать сходство процессора для потока, используйте ProcessThread.ProcessorAffinity метод .
Конструкторы
Инициализирует новый экземпляр класса Stopwatch.
Источник: learn.microsoft.com
Как найти время работы программы на С++
У многих начинающих программистов рано или поздно возникает вопрос: «Как найти время работы программы?». В интернете много ответов на данный вопрос: написать свой мини-дебаггер, посчитать количество тактов и т. д. Самый простой вариант — это посчитать разницу между начальным временем и конечным.
То есть, есть начальное значение времени, после которого объявлен фрагмент кода, время выполнения которого необходимо измерить. После фрагмента кода фиксируется ещё одно, конечное, значение времени. После чего, из конечного значения времени вычитаем начальное время и получим время, за которое выполнился измеряемый фрагмент кода или вся программа. Время работы программы необходимо найти для того, чтобы проверить, насколько эффективнее стал работать отдельный алгоритм или программа в целом! Как это сделать,смотрите ниже.
// Как найти время работы фрагмента кода? // заголовочный файл с прототипом функции 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 секунд. Даже если элементы массива неизменны, время всё равно будет немного отличаться при повторном запуске программы, так как некоторые ресурсы компьютера постоянно будут заняты, а значит, не доступны программе. Если Вы запустите эту программу у себя на компьютере, то время выполнения программы может быть совсем другим, так как наши машины не идентичны.
Источник: cppstudio.com
Замерить время работы функции на С++
Мне нужно замерить время выполнения фрагмента кода (можно функции) на С++. Я прочитал, что для этого используется 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 secondsn», 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 . Реальное время лучше отражает потребляемый ресурс процессора, т.к. если текущий процесс простаивает на кластере (где выполняются сотни других приложений), то он вытесняется операционной системой и практически не загружает процессор.
Источник: pro-prof.com