Как найти время выполнения программы - Сайт, где вы сможете решить свои вопросы

В этом посте будет обсуждаться, как найти время выполнения программы C в средах Windows и Linux.

Существует четыре широко используемых метода определения времени выполнения программы на C:

1. Использование `clock()` функция

Мы можем использовать clock() функция, предоставляемая <time.h> заголовочный файл для расчета времени ЦП, потребляемого задачей в приложении C. Он возвращает clock_t type, в котором хранится общее количество тактов часов.

Чтобы вычислить общее количество прошедших секунд, нам нужно разделить общее количество прошедших тактов часов на CLOCKS_PER_SEC макрос (также присутствует в <time.h>) как показано ниже:

#include <stdio.h>

#include <time.h> // for clock_t, clock(), CLOCKS_PER_SEC

#include <unistd.h> // for sleep()

// основная функция для определения времени выполнения программы на C

int main()

{

// для хранения времени выполнения кода

double time_spent = 0.0;

clock_t begin = clock();

// делаем здесь что-нибудь

sleep(3);

clock_t end = clock();

// рассчитать прошедшее время, найдя разницу (end – begin) и

// деление разницы на CLOCKS_PER_SEC для перевода в секунды

time_spent += (double)(end – begin) / CLOCKS_PER_SEC;

printf(“The elapsed time is %f seconds”, time_spent);

return 0;

}

Скачать Выполнить код

Выход (может варьироваться):

The elapsed time is 0.000014 seconds

Обратите внимание, что clock() Функция не возвращает фактическое количество прошедшего времени, а возвращает количество времени, которое потребовалось базовой операционной системе для запуска процесса. Другими словами, фактическое время настенных часов может быть намного больше.

2. Использование `time()` функция

The <time.h> заголовок также предоставляет time() функция, которая возвращает общее количество секунд, прошедших с начала Эпохи (00:00:00 UTC, 1 января 1970 г.). Он принимает указатель на time_t в качестве аргумента, который обычно передается как NULL и возвращает time_t тип. Если аргумент не NULL, то возвращаемое значение также сохраняется в памяти, на которую указывает аргумент.

Его использование аналогично clock() функцию, как показано ниже:

#include <stdio.h>

#include <time.h> // for time()

#include <unistd.h> // for sleep()

// основная функция для определения времени выполнения программы на C

int main()

{

time_t begin = time(NULL);

// делаем здесь что-нибудь

sleep(3);

time_t end = time(NULL);

// вычислить прошедшее время, найдя разницу (end – begin)

printf(“The elapsed time is %d seconds”, (end – begin));

return 0;

}

Скачать Выполнить код

результат:

The elapsed time is 3 seconds

3. Использование `gettimeofday()` функция

The gettimeofday() Функция возвращает время настенных часов, прошедшее с начала эпохи, и сохраняет его в timeval структура, выраженная в секундах и микросекундах.

Он определен в <sys/time.h> заголовочный файл и принимает два аргумента — первый аргумент является ссылкой на timeval структура, а второй аргумент — нулевой указатель. timeval структура объявляется следующим образом: <time.h> заголовок:

struct timeval {
long tv_sec; /* seconds */
long tv_usec; /* microseconds */
};

Следующий код демонстрирует использование gettimeofday() путем измерения времени настенных часов:

#include <stdio.h>

#include <sys/time.h> // for gettimeofday()

#include <unistd.h> // for sleep()

// основная функция для определения времени выполнения программы на C

int main()

{

struct timeval start, end;

gettimeofday(&start, NULL);

// делаем здесь что-нибудь

sleep(5);

gettimeofday(&end, NULL);

long seconds = (end.tv_sec – start.tv_sec);

long micros = ((seconds * 1000000) + end.tv_usec) – (start.tv_usec);

printf(“The elapsed time is %d seconds and %d microsn”, seconds, micros);

return 0;

}

Скачать Выполнить код

Выход (может варьироваться):

The elapsed time is 5 seconds and 5000147 micros

Эта функция поддерживается компиляторами GCC и может не работать в Windows.

4. Использование `clock_gettime()` функция

Мы также можем использовать clock_gettime() функция, определенная в <time.h> заголовочный файл, который поддерживает точность до наносекунд. Он принимает два аргумента: первый аргумент — это тип часов, а второй аргумент — указатель на timespec структура. timespec структура обеспечивается <time.h> заголовок и объявляется как:

struct timespec {
time_t tv_sec; /* seconds */
long tv_nsec; /* nanoseconds */
};

Следующий код вычисляет прошедшее время, используя общесистемные часы реального времени, обозначенные как CLOCK_REALTIME, время которого представляет секунды и наносекунды с начала Эпохи.

#include <stdio.h>

#include <time.h> // for clock_t, clock()

#include <unistd.h> // for sleep()

#define BILLION 1000000000.0

// основная функция для определения времени выполнения программы на C

int main()

{

struct timespec start, end;

clock_gettime(CLOCK_REALTIME, &start);

// делаем здесь что-нибудь

sleep(3);

clock_gettime(CLOCK_REALTIME, &end);

// time_spent = конец – начало

double time_spent = (end.tv_sec – start.tv_sec) +

(end.tv_nsec – start.tv_nsec) / BILLION;

printf(“The elapsed time is %f seconds”, time_spent);

return 0;

}

Скачать код

Обратите внимание, что clock_gettime() будет работать только на очень немногих машинах UNIX.

Вот и все, что касается нахождения времени выполнения программы на C.

Связанный пост:

Измерьте прошедшее время программы C++ с помощью библиотеки Chrono

Источник

In this article, we will discuss how to check the execution time of a Python script.

There are many Python modules like time, timeit and datetime module in Python which can store the time at which a particular section of the program is being executed. By manipulating or getting the difference between times of beginning and ending at which a particular section is being executed, we can calculate the time it took to execute the section.

The following methods can be used to compute time difference:

Python time module provides various time-related functions. This module comes under Python’s standard utility modules. time.time() method of the Time module is used to get the time in seconds since epoch. The handling of leap seconds is platform-dependent.
Python datetime module defines a function that can be primarily used to get the current time and date. now() function Return the current local date and time, which is defined under the datetime module.
Python timeit module runs your snippet of code n number of times (the default value is, 1000000) so that you get the statistically most relevant measurement of code execution time.

Using the time module check the execution time of Python

Example 1: Measuring time taken for a code segment by recording start and end times

Computing the time using the time module and time.time() function. We have computed the time of the above program, which came out of the order 10^-3. We can check for the time by increasing the number of computations using the same algorithms.

Python3

import time

start = time.time()

a = 0

for i in range(1000):

a += (i**100)

end = time.time()

print("The time of execution of above program is :",

(end-start) * 10**3, "ms")

Output:

The time of execution of above program is : 0.77056884765625 ms

Example 2: Measuring time taken for a code segment by adding up the time required per iteration

Checking times for execution of the program for different numbers of computations. We see a general trend in the increase in time of computation for an increase in the number of execution. However, it may not show any linear trend or fixed increments.

Python3

import time

for j in range(100, 5501, 100):

start = time.time()

a = 0

for i in range(j):

a += (i**100)

end = time.time()

print(f"Iteration: {j}tTime taken: {(end-start)*10**3:.03f}ms")

Output:

Iteration: 100    Time taken: 0.105ms
Iteration: 200    Time taken: 0.191ms
Iteration: 300    Time taken: 0.291ms
Iteration: 400    Time taken: 0.398ms
Iteration: 500    Time taken: 0.504ms
Iteration: 600    Time taken: 0.613ms
Iteration: 700    Time taken: 0.791ms
...
Iteration: 5400    Time taken: 6.504ms
Iteration: 5500    Time taken: 6.630ms

Explanation: Here we have truncated the output for representation purpose. But if we compare the iterations from 100 to 700 they are less than 1ms. But towards the end of the loop, each iteration taking ~7ms. Thus, there is an increase in time taken as the number of iterations have increased. This is generally because, the inner loop iterate more number of time depending on each outer iteration.

Using the DateTime module check the execution time

Using the datetime module in Python and datetime.now() function to record timestamp of start and end instance and finding the difference to get the code execution time.

Python3

from datetime import datetime

start = datetime.now()

a = 0

for i in range(1000):

a += (i**100)

end = datetime.now()

td = (end - start).total_seconds() * 10**3

print(f"The time of execution of above program is : {td:.03f}ms")

Output:

The time of execution of above program is : 0.766ms

Using timeit module check the execution time

This would give us the execution time of any program. This module provides a simple way to find the execution time of small bits of Python code. It provides the timeit() method to do the same. The module function timeit.timeit(stmt, setup, timer, number) accepts four arguments:

stmt which is the statement you want to measure; it defaults to ‘pass’.
setup, which is the code that you run before running the stmt; it defaults to ‘pass’. We generally use this to import the required modules for our code.
timer, which is a timeit.Timer object; usually has a sensible default value, so you don’t have to worry about it.
The number, which is the number of executions you’d like to run the stmt.

Example 1: Using timeit inside Python code snippet to measure execution time

Python3

import timeit

mysetup = "from math import sqrt"

mycode =

exec_time = timeit.timeit(stmt=mycode,

setup=mysetup,

number=1000000) * 10**3

print(f"The time of execution of above program is : {exec_time:.03f}ms")

Output:

The time of execution of above program is : 71.161ms

Example 2: Using timeit from command line to measure execution time

We can measure time taken by simple code statements without the need to write new Python files, using timeit CLI interface.

timeit supports various command line inputs, Here we will note a few of the mos common arguments:

-s [–setup]: Setup code to run before running the code statement.
-n [–number]: Number of times to execute the statement.
–p [–process]: Measure the process time of the code execution, instead of the wall-clock time.
Statement: The code statements to test the execution time, taken as a positional argument.

timeit CLI statement:

python -m timeit -s "import random" "l = [x**9 for x in range(random.randint(1000, 1500))]"

Output:

500 loops, best of 5: 503 used per loop

Last Updated :
26 Apr, 2023

Like Article

Save Article

Источник

У многих начинающих программистов рано или поздно возникает вопрос: «Как найти время работы программы?». В интернете много ответов на данный вопрос: написать свой мини-дебаггер, посчитать количество тактов и т. д. Самый простой вариант — это посчитать разницу между начальным временем и конечным. То есть, есть начальное значение времени, после которого объявлен фрагмент кода, время выполнения которого необходимо измерить. После фрагмента кода фиксируется ещё одно, конечное, значение времени. После чего, из конечного значения времени вычитаем начальное время и получим время, за которое выполнился измеряемый фрагмент кода или вся программа. Время работы программы необходимо найти для того, чтобы проверить, насколько эффективнее стал работать отдельный алгоритм или программа в целом! Как это сделать,смотрите ниже.

// Как найти время работы фрагмента кода?

// заголовочный файл с прототипом функции clock()
#include <ctime> 
//         ...
    unsigned int start_time =  clock(); // начальное время
    // здесь должен быть фрагмент кода, время выполнения которого нужно измерить
    unsigned int end_time = clock(); // конечное время
    unsigned int search_time = end_time - start_time; // искомое время

Для того, чтобы найти время работы программы, нужно воспользоваться функцией clock(). Прототип функции clock() находится в заголовочном файле <ctime>, который нужно подключить, строка 4. Функция clock() возвращает значение времени в миллисекундах (1с = 1000млс). Причём отсчёт времени начинается с момента запуска программы. Если надо измерить работу всей программы, то в конце программы, перед оператором return 0; нужно запустить функцию clock(), которая покажет рабочее время. Для поиска времени работы фрагмента кода нужно найти разницу между конечным и начальным временем, как показано выше.

// Как найти время работы программы?

    // заголовочный файл с прототипом функции clock()
    #include <ctime> 
    //         ...
    // здесь должен быть код программы, время выполнения которой нужно измерить
    unsigned int end_time = clock(); // время работы программы

Разработаем программу, в которой с помощью функции clock() вычислим время работы программы. Программа ищет минимальное значение в массиве размером в 200000 элементов. Размер массива специально выбран большим, для того, чтобы было заметно, как работает программа. Так как числа генерируются случайно, то при каждом запуске получается новый случай, и время может не совпадать. К тому же, время выполнения программы зависит от того, насколько загружен компьютер и от того, какая у компьютера вычислительная мощность. На разных машинах по-разному будет затрачиваться время на выполнение программы, на более мощных компьютерах затрачиваемое время будет меньше и наоборот.

MVS
Code::Blocks
Dev-C++
QtCreator

// runtime.cpp: определяет точку входа для консольного приложения.
// Как найти время работы программы?

#include "stdafx.h"
#include <iostream>
#include <ctime>                     
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 << array1[counter] << " "; // печать элементов одномерного массива array1
    }
    int min = array1[0]; // переменная для хранения минимального значения
    for (int counter = 1; counter < array_size; counter++)
    {
     if ( min > array1[counter] ) // поиск минимального значения в одномерном массиве
         min = array1[counter];
    }
    cout << "nmin = " << min << endl; 
    cout << "runtime = " << clock()/1000.0 << endl; // время работы программы                   
    system("pause");
    return 0;
}

// runtime.cpp: определяет точку входа для консольного приложения.
// Как найти время работы программы?

#include <iostream>
#include <ctime>
#include <cstdlib>
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 << array1[counter] << " "; // печать элементов одномерного массива array1
    }
    int min = array1[0]; // переменная для хранения минимального значения
    for (int counter = 1; counter < array_size; counter++)
    {
     if ( min > array1[counter] ) // поиск минимального значения в одномерном массиве
         min = array1[counter];
    }
    cout << "nmin = " << min << endl;
    cout << "runtime = " << clock()/1000.0 << endl; // время работы программы
    return 0;
}

В строке 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 секунд. Даже если элементы массива неизменны, время всё равно будет немного отличаться при повторном запуске программы, так как некоторые ресурсы компьютера постоянно будут заняты, а значит, не доступны программе. Если Вы запустите эту программу у себя на компьютере, то время выполнения программы может быть совсем другим, так как наши машины не идентичны.

Источник

I have written a c++ program , I want to know how to calculate the time taken for execution so I won’t exceed the time limit.

#include<iostream>

using namespace std;

int main ()
{
    int st[10000],d[10000],p[10000],n,k,km,r,t,ym[10000];
    k=0;
    km=0;
    r=0;
    scanf("%d",&t);
    for(int y=0;y<t;y++)
    {
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
            cin>>st[i] >>d[i] >>p[i];
    }
    for(int i=0;i<n;i++)
    {
            for(int j=i+1;j<n;j++)
            {
                    if((d[i]+st[i])<=st[j])
                    {
                              k=p[i]+p[j];
                    }
                    if(k>km)
                    km=k;
            }
        if(km>r)
        r=km;
    }
    ym[y]=r;
}
    for( int i=0;i<t;i++)
    {
         cout<<ym[i]<<endl;
    }


    //system("pause");
    return 0;
}

this is my program and i want it to be within time limit 3 sec !! how to do it ?
yeah sorry i meant execution time !!

B Faley

17k42 gold badges130 silver badges222 bronze badges

asked May 18, 2009 at 9:37

If you have cygwin installed, from it’s bash shell, run your executable, say MyProgram, using the time utility, like so:

/usr/bin/time ./MyProgram

This will report how long the execution of your program took — the output would look something like the following:

real    0m0.792s
user    0m0.046s
sys     0m0.218s

You could also manually modify your C program to instrument it using the clock() library function, like so:

#include <time.h>
int main(void) {
    clock_t tStart = clock();
    /* Do your stuff here */
    printf("Time taken: %.2fsn", (double)(clock() - tStart)/CLOCKS_PER_SEC);
    return 0;
}

answered May 18, 2009 at 9:56

Ashutosh MehraAshutosh Mehra

2,5721 gold badge18 silver badges15 bronze badges

With C++11 for measuring the execution time of a piece of code, we can use the now() function:

auto start = chrono::steady_clock::now();

//  Insert the code that will be timed

auto end = chrono::steady_clock::now();

// Store the time difference between start and end
auto diff = end - start;

If you want to print the time difference between start and end in the above code, you could use:

cout << chrono::duration <double, milli> (diff).count() << " ms" << endl;

If you prefer to use nanoseconds, you will use:

cout << chrono::duration <double, nano> (diff).count() << " ns" << endl;

The value of the diff variable can be also truncated to an integer value, for example, if you want the result expressed as:

diff_sec = chrono::duration_cast<chrono::nanoseconds>(diff);
cout << diff_sec.count() << endl;

For more info click here

answered Dec 19, 2017 at 13:27

SajalSajal

1,7731 gold badge17 silver badges21 bronze badges

OVERVIEW

I have written a simple semantic hack for this using @AshutoshMehraresponse. You code looks really readable this way!

MACRO

#include <time.h>

#ifndef SYSOUT_F
#define SYSOUT_F(f, ...)      _RPT1( 0, f, __VA_ARGS__ ) // For Visual studio
#endif

#ifndef speedtest__             
#define speedtest__(data)   for (long blockTime = NULL; (blockTime == NULL ? (blockTime = clock()) != NULL : false); SYSOUT_F(data "%.9fs", (double) (clock() - blockTime) / CLOCKS_PER_SEC))
#endif

USAGE

speedtest__("Block Speed: ")
{
    // The code goes here
}

OUTPUT

Block Speed: 0.127000000s

answered Jan 24, 2014 at 7:46

Mathew KurianMathew Kurian

5,9195 gold badges45 silver badges73 bronze badges

Note: the question was originally about compilation time, but later it turned out that the OP really meant execution time. But maybe this answer will still be useful for someone.

For Visual Studio: go to Tools / Options / Projects and Solutions / VC++ Project Settings and set Build Timing option to ‘yes‘. After that the time of every build will be displayed in the Output window.

answered May 18, 2009 at 9:56

Alex JenterAlex Jenter

4,3044 gold badges35 silver badges61 bronze badges

You can try below code for c++:

#include <chrono>


auto start = std::chrono::system_clock::now();
// Your Code to Execute //
auto end = std::chrono::system_clock::now();
std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << "ms" << std::endl;

answered Aug 30, 2021 at 10:40

KRGKRG

4606 silver badges16 bronze badges

This looks like Dijstra’s algorithm. In any case, the time taken to run will depend on N. If it takes more than 3 seconds there isn’t any way I can see of speeding it up, as all the calculations that it is doing need to be done.

Depending on what problem you’re trying to solve, there might be a faster algorithm.

answered May 18, 2009 at 13:01

pjc50pjc50

1,83616 silver badges18 bronze badges

I have used the technique said above, still I found that the time given in the Code:Blocks IDE was more or less similar to the result obtained-(may be it will differ by little micro seconds)..

answered Apr 8, 2013 at 4:07

ejjyrexejjyrex

1,1511 gold badge10 silver badges13 bronze badges

If you are using C++ then you should try this below code as you would always get 0 as answer if you directly use @Ashutosh Mehra’s answer.

#include <iostream>
#include <time.h>

using namespace std;

int main() {
    int a = 20000, sum=0;
    
    clock_t start = clock();
    for (int i=0; i<a; i++) {
        for (int k = 0; k<a; k++)
            sum += 1;
    }
    cout.precision(10);
    cout << fixed <<  float(clock() - start)/CLOCKS_PER_SEC  << endl;
    return 0;
}

Because in C++ you the float and double values will directly be rounded off. So I used the cout.precision(10) to set the output precision of any value to 10 digits after decimal.

greybeard

2,1657 gold badges28 silver badges64 bronze badges

answered Jun 26, 2021 at 16:52

shorter version of Ashutosh Mehra’s answer:

/* including stuff here */
#include <time.h>
int main(void) {
    clock_t tStart = clock();
    /* stuff here */
    cout<<"Time taken: "<<(double)(clock() - tStart)/CLOCKS_PER_SEC;
    return 0;
}

answered Sep 14, 2022 at 9:04

Источник

Замерить время работы функции на С++

В этой теме 2 ответа, 2 участника, последнее обновление 6 лет, 10 месяцев назад сделано .

Сообщения
- Мне нужно замерить время выполнения фрагмента кода (можно функции) на С++.
  
  Я прочитал, что для этого используется clock() из модуля time.h (ctime) — она возвращает число таков, измеряемое процессором от начала выполнения программы.
  Глобальная константа CLOCKS_PER_SEC хранит число тактов, выполняемое процессором в секунду. Соответственно, чтобы получить время работы программы в секундах достаточно результат работы функции разделить на эту константу:
  clock() / CLOCKS_PER_SEC;
  
  Для определения времени работы фрагмента программы нужно определить моменты времени до фрагмента и после него, а затем — посчитать разницу. Однако следующий фрагмент кода работает не так, как мне хотелось бы:
```
#include <stdio .h> 
#include <time .h> 

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 я ставлю фрагмент кода, выполняющий какие-либо вычисления — выводится правдоподобный результат.
  
  Подскажите в чем проблема и как ее решить.
- Функция clock() возвращает количество тиков процессора, которое сделала именно ваша программа, т.е. если программа ожидает ввод данных пользователем, то она не работает (операционная система вытесняет процесс из очереди задач). Следовательно нельзя замерить время ожидания ввода при помощи функции clock() — хотя подход, который вы привели, идеально подходит если вы хотите сравнить два алгоритма, т.к. в этом случае меньшее влияние оказывает загруженность системы.
  
  Определить количество секунд, которое выполняется программа можно с помощью функции time():
```
#include <stdio .h> 
#include <time .h> 

int main() {
  time_t start, end;
  
  time(&start);

  getchar(); 

  time(&end);
  
  double seconds = difftime(end, start);

  printf("The time: %f secondsn", seconds);
}
```
  Время при этом сохраняет с типом данных time_t — это целое число секунд, прошедшее с 1 января 1970 года. Функция difftime вычисляет разницу двух моментов времени. С помощью такого подхода вы сможете замерить время работы части программы, однако результат будет в секундах.
- При помощи средств, появившихся в стандартной библиотеке С++11 можно получить более высокую точность измерения и замерить время независимо от системных часов (с помощью так называемых стабильных часов). Обзор библиотеки chrono.
  
  Следующий фрагмент кода выполняет замер времени с использованием стабильных часов:
```
#include <iostream>
#include <chrono>

int main() {
  auto begin = std::chrono::steady_clock::now();

  getchar(); 

  auto end = std::chrono::steady_clock::now();
  
  auto elapsed_ms = std::chrono::duration_cast<std::chrono::milliseconds>(end - begin);

  std::cout << "The time: " << elapsed_ms.count() << " msn";
}
```
  Функция std::chrono::duration_cast преобразует объект типа <code>time_point во временной интервал (duration), при этом в качестве параметра шаблона передается промежуток времени в виде долей секунды (в данном случае миллисекунды).
  
  Использование библиотеки chrono — лучший способ если нужно фактическое замерить время выполнения программы (в отличии функции time(), модуля time.h она позволяет получить время в миллисекундах и даже наносекундах). Однако если программа работает на многопроцессорной системе и часто ожидает какие-либо данные (не только пользовательский ввод, но и данных от других потоков/процессов) — то больший интерес может представлять реальное время выполнения, возвращаемое функцией clock() модуля time.h. Реальное время лучше отражает потребляемый ресурс процессора, т.к. если текущий процесс простаивает на кластере (где выполняются сотни других приложений), то он вытесняется операционной системой и практически не загружает процессор.
Автор

Сообщения

Для ответа в этой теме необходимо авторизоваться.

Источник

1. Использование clock() функция

2. Использование time() функция

3. Использование gettimeofday() функция

4. Использование clock_gettime() функция

Using the time module check the execution time of Python

Example 1: Measuring time taken for a code segment by recording start and end times

Python3

Example 2: Measuring time taken for a code segment by adding up the time required per iteration

Python3

Using the DateTime module check the execution time

Python3

Using timeit module check the execution time

Example 1: Using timeit inside Python code snippet to measure execution time

Python3

Example 2: Using timeit from command line to measure execution time

Замерить время работы функции на С++

Вам также может понравиться

0x000006ba ошибка как исправить windows 7

Как найти страницу вк по короткому имени

Как на виндовс 10 найти hdd

Добавить комментарий Отменить ответ

1. Использование `clock()` функция

2. Использование `time()` функция

3. Использование `gettimeofday()` функция

4. Использование `clock_gettime()` функция