CODEWITHSUNDEEP
ctime
Chris
Chris

Reputation: 3698

Trying to get the time of an operation and receiving time 0 seconds

I am trying to see how much does it take for about 10000 names to be inserted into a BST(writing in c).

I am reading these names from a txt file using fscanf. I have declared a file pointer(fp) at the main function. Calling a function that is at another .c file passing the fp through its arguments. I want to count the time needed for 2,4,8,16,32...,8192 names to be inserted saving the time at a long double array. I have included the time.h library at the .c file where the function is located.

Code:

void myfunct(BulkTreePtr *Bulktree, FILE* fp,long double time[])
{
    double tstart, tend, ttemp;
    TStoixeioyTree datainput;
    int error = 0,counter=0,index=0,num=2,i;
    tstart =  ((double) clock())/CLOCKS_PER_SEC;
    while (!feof(fp))
    {
        counter++;
        fscanf(fp,"%s %s", datainput.lname, datainput.fname);
        Tree_input(&((*Bulktree)->TreeRoot), datainput, &error);
        if (counter == num)
        {
            ttemp =  (double) clock()/CLOCKS_PER_SEC;
            time[index] = ttemp-tstart;
            num = num * 2;
            index++;
        }   
    }
    tend =  ((double) clock())/CLOCKS_PER_SEC;
    printf("Last value of ttemp is %f\n",ttemp-tstart);
    time[index] = (tend-tstart);
    num = 2;
    for(i=0;i<14;i++)
    {
        printf("Time after %d names is %f sec \n", num, (float)time[i]);
        num=num*2;
    }

I am getting this:

Last value of ttemp is 0.000000
Time after 2 names is 0.000000 sec
Time after 4 names is 0.000000 sec
Time after 8 names is 0.000000 sec
Time after 16 names is 0.000000 sec
Time after 32 names is 0.000000 ms
Time after 64 names is 0.000000 sec
Time after 128 names is 0.000000 sec
Time after 256 names is 0.000000 sec
Time after 512 names is 0.000000 sec
Time after 1024 names is 0.000000 sec
Time after 2048 names is 0.000000 sec
Time after 4096 names is 0.000000 sec
Time after 8192 names is 0.000000 sec
Time after 16384 names is 0.010000 sec

What am I doing wrong? :S

Upvotes: 2

Views: 594

Answers (4)

JohnMudd
JohnMudd

Reputation: 13823

ImageMagick includes stopwatch functions such as these.

#include "magick/MagickCore.h"
#include "magick/timer.h"

TimerInfo *timer_info;
timer_info = AcquireTimerInfo();
<your code>
printf("elapsed=%.6f sec", GetElapsedTime(timer_info));

But that only seems to have a resolution of 1/100 second. Plus it requires installing ImageMagic. I suggest this instead. It's simple and has usec resolution in Linux.

#include <time.h>  
double timer(double start_secs)
{   
    static struct timeval  tv;
    static struct timezone tz;
    gettimeofday(&tv, &tz);
    double now_secs = (double)tv.tv_sec + (double)tv.tv_usec/1000000.0;
    return now_secs - start_secs;
}

double t1 = timer(0);
<your code>
printf("elapsed=%.6f sec", timer(t1));

Upvotes: 0

R.. GitHub STOP HELPING ICE
R.. GitHub STOP HELPING ICE

Reputation: 215547

clock returns the amount of cpu time used, not the amount of actual time elapsed, but that might be what you want here. Note that Unix standards requires CLOCKS_PER_SECOND to be exactly one million (1000000), but the resolution can be much worse (e.g. it might jump by 10000 at a time). You should be using clock_gettime with the cpu time clock if you want to measure cpu time spent, or otherwise with the monotonic clock to measure realtime spent.

Upvotes: 0

MRAB
MRAB

Reputation: 20664

clock() returns the number of "ticks"; there are CLOCKS_PER_SEC ticks per second. For any operation which takes less than 1/CLOCKS_PER_SEC seconds, the return value of clock() will either be unchanged or changed by 1 tick.

From your results it looks like even 16384 insertions take no more than 1/100 seconds.

If you want to know how long a certain number of insertions take, try repeating them many, many times so that the total number of ticks is significant, and then divide that total time by the number of times they were repeated.

Upvotes: 0

Seth Robertson
Seth Robertson

Reputation: 31471

Use clock_getres() and clock_gettime(). Most likely you will find your system doesn't have a very fast clock. Note that the system might return different numbers when calling gettimeofday or clock_gettime(), but often times (depending on kernel) those numbers at greater than HZ resolution are lies generated to simulate time advancing.

You might find a better test to do fixed time tests. Find out how many inserts you can do in 10 seconds. Or have some kind of fast reset method (memset?) and find out how many groups of inserts of 1024 names you can do in 10 seconds.

[EDIT]

Traditionally, the kernel gets interrupted at HZ frequency by the hardware. Only when it gets this hardware interrupt does it know that time had advanced by 1/HZ of a second. The traditional value for HZ was 1/100 of a second. Surprise, surprise, you saw a 1/100th of a second increment in time. Now some systems and kernels have recently started providing other methods of getting higher resolution time, looking at the RTC device or whatever.

However, you should use the clock_gettime() function I pointed you to along with the clock_getres() function to find out how often you will get accurate time updates. Make sure your test runs many many multiples of clock_getres() unless you want it to be a total lie.

Upvotes: 1

Related Questions