Как измерить время работы программы си в миллисекундах

Using the following code:

#include<stdio.h>
#include<time.h>
int main()
{
    clock_t start, stop;
    int i;
    start = clock();
    for(i=0; i<2000;i++)
    {
        printf("%d", (i*1)+(1^4));
    }
    printf("nn");
    stop = clock();

    //(double)(stop - start) / CLOCKS_PER_SEC

    printf("%6.3f", start);
    printf("nn%6.3f", stop);
    return 0;
}

I get the following output:

56789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004

  2.169

  2.169

Start and stop times are the same. Does it mean that the program hardly takes time to complete execution?
If 1. is false, then atleast the no.of digits beyond the (.) should differ, which does not happen here. Is my logic correct?

Note: I need to calculate the time taken for execution, and hence the above code.

Cœur

36.6k25 gold badges191 silver badges259 bronze badges

asked Apr 17, 2012 at 14:11

Yes, this program has likely used less than a millsecond. Try using microsecond resolution with timeval.

e.g:

#include <sys/time.h>

struct timeval stop, start;
gettimeofday(&start, NULL);
//do stuff
gettimeofday(&stop, NULL);
printf("took %lu usn", (stop.tv_sec - start.tv_sec) * 1000000 + stop.tv_usec - start.tv_usec);

You can then query the difference (in microseconds) between stop.tv_usec - start.tv_usec. Note that this will only work for subsecond times (as tv_usec will loop). For the general case use a combination of tv_sec and tv_usec.

Edit 2016-08-19

A more appropriate approach on system with clock_gettime support would be:

struct timespec start, end;
clock_gettime(CLOCK_MONOTONIC_RAW, &start);
//do stuff
clock_gettime(CLOCK_MONOTONIC_RAW, &end);

uint64_t delta_us = (end.tv_sec - start.tv_sec) * 1000000 + (end.tv_nsec - start.tv_nsec) / 1000;

sdasdadas

23.4k20 gold badges61 silver badges146 bronze badges

answered Apr 17, 2012 at 14:17

cmhcmh

10.5k5 gold badges29 silver badges40 bronze badges

Here is what I write to get the timestamp in millionseconds.

#include<sys/time.h>

long long timeInMilliseconds(void) {
    struct timeval tv;

    gettimeofday(&tv,NULL);
    return (((long long)tv.tv_sec)*1000)+(tv.tv_usec/1000);
}

answered Jul 4, 2017 at 3:01

zebo zhuangzebo zhuang

5461 gold badge5 silver badges15 bronze badges

A couple of things might affect the results you’re seeing:

You’re treating clock_t as a floating-point type, I don’t think it is.
You might be expecting (1^4) to do something else than compute the bitwise XOR of 1 and 4., i.e. it’s 5.
Since the XOR is of constants, it’s probably folded by the compiler, meaning it doesn’t add a lot of work at runtime.
Since the output is buffered (it’s just formatting the string and writing it to memory), it completes very quickly indeed.

You’re not specifying how fast your machine is, but it’s not unreasonable for this to run very quickly on modern hardware, no.

If you have it, try adding a call to sleep() between the start/stop snapshots. Note that sleep() is POSIX though, not standard C.

answered Apr 17, 2012 at 14:16

unwindunwind

388k64 gold badges468 silver badges601 bronze badges

This code snippet can be used for displaying time in seconds,milliseconds and microseconds:

#include <sys/time.h>

struct timeval start, stop;
double secs = 0;

gettimeofday(&start, NULL);

// Do stuff  here

gettimeofday(&stop, NULL);
secs = (double)(stop.tv_usec - start.tv_usec) / 1000000 + (double)(stop.tv_sec - start.tv_sec);
printf("time taken %fn",secs);

answered Jul 27, 2015 at 11:45

K_KK_K

7597 silver badges18 bronze badges

You can use gettimeofday() together with the timedifference_msec() function below to calculate the number of milliseconds elapsed between two samples:

#include <sys/time.h>
#include <stdio.h>

float timedifference_msec(struct timeval t0, struct timeval t1)
{
    return (t1.tv_sec - t0.tv_sec) * 1000.0f + (t1.tv_usec - t0.tv_usec) / 1000.0f;
}

int main(void)
{
   struct timeval t0;
   struct timeval t1;
   float elapsed;

   gettimeofday(&t0, 0);
   /* ... YOUR CODE HERE ... */
   gettimeofday(&t1, 0);

   elapsed = timedifference_msec(t0, t1);

   printf("Code executed in %f milliseconds.n", elapsed);

   return 0;
}

Note that, when using gettimeofday(), you need to take seconds into account even if you only care about microsecond differences because tv_usec will wrap back to zero every second and you have no way of knowing beforehand at which point within a second each sample is obtained.

answered Dec 12, 2014 at 17:29

Adrian LopezAdrian Lopez

1,6641 gold badge16 silver badges21 bronze badges

From man clock:

The clock() function returns an approximation of processor time used by the program.

So there is no indication you should treat it as milliseconds. Some standards require precise value of CLOCKS_PER_SEC, so you could rely on it, but I don’t think it is advisable.
Second thing is that, as @unwind stated, it is not float/double. Man times suggests that will be an int.
Also note that:

this function will return the same value approximately every 72 minutes

And if you are unlucky you might hit the moment it is just about to start counting from zero, thus getting negative or huge value (depending on whether you store the result as signed or unsigned value).

This:

printf("nn%6.3f", stop);

Will most probably print garbage as treating any int as float is really not defined behaviour (and I think this is where most of your problem comes). If you want to make sure you can always do:

printf("nn%6.3f", (double) stop);

Though I would rather go for printing it as long long int at first:

printf("nn%lldf", (long long int) stop);

answered Apr 17, 2012 at 14:29

elmoelmo

1,1691 gold badge10 silver badges34 bronze badges

The standard C library provides timespec_get. It can tell time up to nanosecond precision, if the system supports. Calling it, however, takes a bit more effort because it involves a struct. Here’s a function that just converts the struct to a simple 64-bit integer so you can get time in milliseconds.

#include <stdio.h>
#include <inttypes.h>
#include <time.h>

int64_t millis()
{
    struct timespec now;
    timespec_get(&now, TIME_UTC);
    return ((int64_t) now.tv_sec) * 1000 + ((int64_t) now.tv_nsec) / 1000000;
}

int main(void)
{
    printf("Unix timestamp with millisecond precision: %" PRId64 "n", millis());
}

Unlike clock, this function returns a Unix timestamp so it will correctly account for the time spent in blocking functions, such as sleep.

answered Oct 26, 2020 at 14:39

DanielDaniel

5563 silver badges5 bronze badges

Modern processors are too fast to register the running time. Hence it may return zero. In this case, the time you started and ended is too small and therefore both the times are the same after round of.

answered Dec 21, 2015 at 14:25

Code_RunCode_Run

11 silver badge4 bronze badges

Источник

��
��

��
�� , �� gettimeofday(), times(), clock(), : ��
�� , � �� .

� ��
�� , �� Linux � Windows, �� . �� ,
�� (��) <��>.
�� , �� , ��
�� -�� . ��
�� :

��
�� 5 �� (��).
�� — ��
�� . �� (�� 2) ��
�� , � �� , � �� .
�� , �� , ��
�� . ��
�� , �� :

�� —
��, �� , �� . ��
gettimeofday(), ��, �� ,
�� <��> �� . ��
�� <��> �� , ��
��, <��> �� .
�� —
��, ��
(��). �� , �� . ��
��
�� , ��
�� .

��
�� .

1.
�� gettimeofday()

��
gettimeofday() ��
�� . ��
�� .

�� Linux:

#include
<sys/time.h>

struct timeval tv1,tv2,dtv;

struct timezone tz;

void time_start() { gettimeofday(&tv1,
&tz); }

long time_stop()

{ gettimeofday(&tv2, &tz);

� dtv.tv_sec=
tv2.tv_sec -tv1.tv_sec;

� dtv.tv_usec=tv2.tv_usec-tv1.tv_usec;

� if(dtv.tv_usec<0)
{ dtv.tv_sec—; dtv.tv_usec+=1000000;
}

� return dtv.tv_sec*1000+dtv.tv_usec/1000;

}

��
time_stop() �� , �� time_start(), �
��. �� :

main()

{

�� .
. .

time_start();

/* ��-��
�� */

printf(«Time: %ldn», time_stop());

�� . . .

}

2. ��
�� times()

��
times() �� . ��
�� , ��
�� , �� IA-32/Linux — 10ms, Alpha/Linux — 1ms. ��, ��
�� .

�� Linux:

#include
<sys/times.h>

#include <time.h>

struct tms tmsBegin,tmsEnd;

void time_start() { times(&tmsBegin);
}

long time_stop()

{ times(&tmsEnd);

� return ((tmsEnd.tms_utime-tmsBegin.tms_utime)+

�� (tmsEnd.tms_stime-tmsBegin.tms_stime))*1000/CLK_TCK;

}

��
time_stop() �� , �� time_start, �
��. �� .

3.
�� .

��
�� — �� ,
�� . ��
RDTSC (Read Time Stamp Counter) �� EDX � EAX 64-��
�� , ��
�� . �� , ��
�� , ��
�� . �� , ��
�� . ��
�� (��, ��
��). �� 1�� — 1 ��.

��
�� .

��:
�� .�� .

�� Linux:

long long TimeValue=0;

unsigned long long time_RDTSC()

{ union ticks

� { unsigned
long long tx;

�� struct dblword { long tl,th; } dw; // little endian

� } t;

� asm(«rdtscn»:
«=a»(t.dw.tl),»=d»(t.dw.th));

� return t.tx;

} // for x86 only!

void time_start() { TimeValue=time_RDTSC(); }

long long time_stop() { return time_RDTSC()-TimeValue; }

��
time_stop �� ,
�� time_start. ��
�� .

4. ��
�� , ��

�
�� . �� (��,
�� , �� ), ��,
��
��.

�� 

��
�� — ��. �� . ��
��, �� . ��
��
��. �� , �� , ��
�� . �� ,
�� .

�� 

�
�� . ��
��
�� . � �� Linux ��
�� sync. �� :

�� system(«sync«);

Источник

Как получить время выполнения программы в миллисекундах на языке Си?

В настоящее время я получаю время выполнения моей программы в секундах, вызывая:

time_t startTime = time(NULL);

//section of code

time_t endTime = time(NULL);

double duration = difftime(endTime, startTime);

Можно ли получить время стены в миллисекундах ? Если да, то как?

876

6

6 ответов:

Если вы находитесь на машине POSIX-ish, используйте gettimeofday() вместо этого; это дает вам разумную переносимость и разрешение микросекунды.

Несколько более эзотерическим, но также и в POSIX, является clock_gettime() функция, которая дает вам разрешение наносекунды.

Во многих системах вы найдете функцию ftime(), которая фактически возвращает вам время в секундах и миллисекундах. Однако он больше не входит в единую спецификацию Unix (примерно то же, что и POSIX). Тебе нужно … заголовок <sys/timeb.h>:
struct timeb mt;
if (ftime(&mt) == 0)
{
     mt.time ... seconds
     mt.millitime ... milliseconds
}
Это восходит к версии 7 (или 7-му изданию) Unix, по крайней мере, поэтому она была очень широко доступна.

У меня также есть заметки в моем подсекундном коде таймера на times() и clock(), которые снова используют другие структуры и заголовки. У меня также есть заметки о Windows, использующей clock() с 1000 тактов в секунду (время миллисекунды), и более старый интерфейс GetTickCount(), который отмечен как необходимый на Windows 95, но не на NT.

Если вы можете сделать это вне самой программы, в linux вы можете использовать команду time (time ./my_program).

Недавно я написал пост в блоге, который объясняет, Как получить время в миллисекундах кросс-платформенным .

Он будет работать как time (NULL), но будет возвращать количество миллисекунд вместо секунд из эпохи unix как в windows, так и в linux.

Вот код
#ifdef WIN32
#include <Windows.h>
#else
#include <sys/time.h>
#include <ctime>
#endif

/* Returns the amount of milliseconds elapsed since the UNIX epoch. Works on both
 * windows and linux. */

int64 GetTimeMs64()
{
#ifdef WIN32
 /* Windows */
 FILETIME ft;
 LARGE_INTEGER li;
 uint64 ret;

 /* Get the amount of 100 nano seconds intervals elapsed since January 1, 1601 (UTC) and copy it
  * to a LARGE_INTEGER structure. */
 GetSystemTimeAsFileTime(&ft);
 li.LowPart = ft.dwLowDateTime;
 li.HighPart = ft.dwHighDateTime;

 ret = li.QuadPart;
 ret -= 116444736000000000LL; /* Convert from file time to UNIX epoch time. */
 ret /= 10000; /* From 100 nano seconds (10^-7) to 1 millisecond (10^-3) intervals */

 return ret;
#else
 /* Linux */
 struct timeval tv;
 uint64 ret;

 gettimeofday(&tv, NULL);

 ret = tv.tv_usec;
 /* Convert from micro seconds (10^-6) to milliseconds (10^-3) */
 ret /= 1000;

 /* Adds the seconds (10^0) after converting them to milliseconds (10^-3) */
 ret += (tv.tv_sec * 1000);

 return ret;
#endif
}
Вы можете изменить его, чтобы возвращать микросекунды вместо миллисекунд, если хотите.

Библиотека GLib с открытым исходным кодом имеет систему GTimer, которая утверждает, что обеспечивает микросекундную точность. Эта библиотека доступна в Mac OS X, Windows и Linux. В настоящее время я использую его, чтобы сделать тайминги производительности на Linux, и он, кажется, работает идеально.

gprof, что является частью инструментария GNU, это вариант. В большинстве систем POSIX он будет установлен, и он доступен под Cygwin для Windows. Отслеживание времени самостоятельно с помощью gettimeofday() работает нормально, но это эквивалентно использованию инструкций print для отладки. Это хорошо, если вы просто хотите быстрого и грязного решения, но это не так элегантно, как использовать правильные инструменты.

Чтобы использовать gprof, необходимо указать параметр-pg при компиляции с gcc как в:
gcc -o prg source.c -pg
Тогда вы можете запустить gprof в сгенерированной программе следующим образом:
gprof prg > gprof.out
По умолчанию gprof генерирует общее время выполнения вашей программы, а также количество времени, затраченного на каждую функцию, количество раз, когда каждая функция была вызвана, среднее время, затраченное на каждый вызов функции, и аналогичную информацию.

Существует большое количество опций, которые можно задать с помощью gprof. Если вам интересно, вы можете найти дополнительную информацию на man-страницах или в Google.

В Windows используйте QueryPerformanceCounter и связанную с ним QueryPerformanceFrequency. Они не дают вам время, которое можно перевести в календарное время, поэтому, если вам это нужно, попросите время с помощью CRT API, а затем немедленно используйте QueryPerformanceCounter. Затем вы можете выполнить простое сложение / вычитание для вычисления календарного времени с некоторой ошибкой из-за времени, необходимого для последовательного выполнения API. Эй, это же компьютер, а ты чего ожидал???

Источник

В этом посте будет обсуждаться, как найти время выполнения программы 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

Спасибо за чтение.

Пожалуйста, используйте наш онлайн-компилятор размещать код в комментариях, используя C, C++, Java, Python, JavaScript, C#, PHP и многие другие популярные языки программирования.

Как мы? Порекомендуйте нас своим друзьям и помогите нам расти. Удачного кодирования 🙂

Источник

Best way to answer is with an example:

#include <sys/time.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>

/* Return 1 if the difference is negative, otherwise 0.  */
int timeval_subtract(struct timeval *result, struct timeval *t2, struct timeval *t1)
{
    long int diff = (t2->tv_usec + 1000000 * t2->tv_sec) - (t1->tv_usec + 1000000 * t1->tv_sec);
    result->tv_sec = diff / 1000000;
    result->tv_usec = diff % 1000000;

    return (diff<0);
}

void timeval_print(struct timeval *tv)
{
    char buffer[30];
    time_t curtime;

    printf("%ld.%06ld", tv->tv_sec, tv->tv_usec);
    curtime = tv->tv_sec;
    strftime(buffer, 30, "%m-%d-%Y  %T", localtime(&curtime));
    printf(" = %s.%06ldn", buffer, tv->tv_usec);
}

int main()
{
    struct timeval tvBegin, tvEnd, tvDiff;

    // begin
    gettimeofday(&tvBegin, NULL);
    timeval_print(&tvBegin);

    // lengthy operation
    int i,j;
    for(i=0;i<999999L;++i) {
        j=sqrt(i);
    }

    //end
    gettimeofday(&tvEnd, NULL);
    timeval_print(&tvEnd);

    // diff
    timeval_subtract(&tvDiff, &tvEnd, &tvBegin);
    printf("%ld.%06ldn", tvDiff.tv_sec, tvDiff.tv_usec);

    return 0;
}

Источник

2 / 2 / 1

Регистрация: 19.09.2015

Сообщений: 121

Время выполнения куска программы в миллисекундах

18.03.2017, 22:16. Показов 25205. Ответов 4

Доброго времени суток. Нужен код, позволяющий узнать время выполнения куска кода(желательно в миллисекундах).

Photofenix

63 / 63 / 39

Регистрация: 18.11.2016

Сообщений: 562

18.03.2017, 22:38

C++

#include <iostream>
#include <cstdlib>
#include <Windows.h>
#include <ctime>
 
 
 
int main(){
    SetConsoleCP (1251);
    SetConsoleOutputCP (1251);
 
    int sum;
    clock_t time;
    time = clock();
 
    for (int i(0); i!=1000; i++){
        sum += i;
    }
 
    std::cout << sum << std::endl;
    time = clock() - time;
    std::cout << static_cast<float>(time)/CLOCKS_PER_SEC << std::endl;
 
    system ("pause");
    return 0;
};

Kodirovsshik

16 / 16 / 11

Регистрация: 28.10.2016

Сообщений: 75

18.03.2017, 23:03

C++

#include <iostream>
#include <conio.h>
#include <time.h>
 
using namespace std;
 
int main(int argc, char* argv[]) {
 
    setlocale(LC_ALL,"Russian");
    
    int start_time = clock();
 
    //Код
    //Код
    //Код
    //Код
    //Код
 
    unsigned long long int end_time = clock();
 
    cout << "Время выполнения куска программы: " << end_time - start_time << " миллисекундn";
 
    _getch();
    return 0;
}

nmcf

18.03.2017, 23:10

Не по теме:

Kodirovsshik, там не обязательно будут миллисекунды.

notAll

495 / 209 / 70

Регистрация: 27.05.2016

Сообщений: 557

18.03.2017, 23:52

Отдаю предпочтение чему либо такому:

C++

#include <iostream>
#include <chrono>
 
namespace ch = std::chrono;
 
template <typename duration = ch::seconds, typename clock = ch::high_resolution_clock>
class timer
{
    typename clock::time_point m_start, m_stop;
 
    typename clock::rep get_time() const
    {
        return ch::duration_cast<duration>(m_stop - m_start).count();
    }
 
public:
    void         start() { m_start = clock::now(); }
    const timer& stop()  { m_stop = clock::now(); return *this; }
 
    std::ostream& print() const
    {
        return std::cout << "Time running: [" << get_time() << "]";
    }
};
 
int main()
{
    timer<ch::milliseconds> aTimer;
 
    aTimer.start();
    //your code ...
    aTimer.stop().print() << " milliseconds";
}

Источник

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

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

Сообщения
- Мне нужно замерить время выполнения фрагмента кода (можно функции) на С++.
  
  Я прочитал, что для этого используется 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. Реальное время лучше отражает потребляемый ресурс процессора, т.к. если текущий процесс простаивает на кластере (где выполняются сотни других приложений), то он вытесняется операционной системой и практически не загружает процессор.
Автор

Сообщения

Вы должны войти в систему, чтобы ответить на эту тему.

Источник

Как получить время выполнения программы в миллисекундах на языке Си?

6 ответов:

Вот код

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

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

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

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

Время выполнения куска программы в миллисекундах

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

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

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

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

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