Set time_t to milliseconds

Question

I have a function and I want the function to stop running once it has been running for a certain number of milliseconds. This function works for seconds but I want to test it for milliseconds. How do I do this? If I set eliminate = 1, it corresponds to 1 second. How do I set eliminate = 5 ms?

Function:

void clsfy_proc(S_SNR_TARGET_SET pSonarTargetSet, unsigned char *target_num, time_t eliminate)
{

    // get timing
    time_t _start = time(NULL);
    time_t _end = _start + eliminate;
    int _eliminate = 0;

    //some code

        time_t start = time(NULL);
        time_t end = start + eliminate;

        for(_tidx = 0; _tidx < pSonarTargetSet[_i].num; _tidx++) {
            // check timing
            time_t _current = time(NULL);
            if (_current > _end) {
                printf("clsfy_proc(1), Eliminate due to timeout\n");
                _eliminate = 1;
                break;
            }

            //some code 

        if (_eliminate == 1)
            break;
    }
    //some code 
}

`time_t` almost always represents seconds. Check out `clock_t` instead. It often has nanosecond precision, you can get the exact amount with the `CLOCKS_PER_SEC` macro, and you get a `clock_t` by calling `clock()` (instead of `time()`). — Blaze, Oct 18 '18 at 08:07

score 5 · Accepted Answer · answered Oct 18 '18 at 08:12

time_t is an absolute time, represented as the integer number of seconds since the UNIX epoch (midnight GMT, 1 January 1970). It is useful as an unambiguous, easy-to-work-with representation of a point in time.

clock_t is a relative measurement of time, represented by an integer number of clock ticks since some point in time (possibly the computer's bootup, but no guarantees, as it may roll over quite often). There are CLOCKS_PER_SEC clock ticks per second; the value of this constant can vary between different operating systems. It is sometimes used for timing purposes, but it is not very good at it due to its relatively low resolution.

One small example for clock_t:

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

int main () {
   clock_t start_t, end_t, total_t;
   int i;

   start_t = clock();
   printf("Starting of the program, start_t = %ld\n", start_t);

   for(i=0; i< 10000000; i++) { }

   end_t = clock();
   printf("End of the big loop, end_t = %ld\n", end_t);

   total_t = (double)(end_t - start_t) / CLOCKS_PER_SEC;
   printf("Total time taken by CPU: %f\n", total_t  );

   return(0);
}

Hi, I ran your small example and I got this: Starting of the program, start_t = 467 End of the big loop, end_t = 15575 Total time taken by CPU: 0.000000 Why would the CPU time taken be 0? — Ruven Guna, Oct 18 '18 at 08:56
Okay it ran normally after I declared total_t as a double instead of clock_t — Ruven Guna, Oct 18 '18 at 09:08

score 0 · Answer 2 · answered Oct 18 '18 at 13:05

You can use getrusage(). Please see the example:

Source: http://www.cs.tufts.edu/comp/111/examples/Time/getrusage.c

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

///////////////////////////////////
// measure user and system time using the "getrusage" call. 
///////////////////////////////////
//struct rusage {
//   struct timeval ru_utime; /* user CPU time used */
//   struct timeval ru_stime; /* system CPU time used */
//   long   ru_maxrss;        /* maximum resident set size */
//   long   ru_ixrss;         /* integral shared memory size */
//   long   ru_idrss;         /* integral unshared data size */
//   long   ru_isrss;         /* integral unshared stack size */
//   long   ru_minflt;        /* page reclaims (soft page faults) */
//   long   ru_majflt;        /* page faults (hard page faults) */
//   long   ru_nswap;         /* swaps */
//   long   ru_inblock;       /* block input operations */
//   long   ru_oublock;       /* block output operations */
//   long   ru_msgsnd;        /* IPC messages sent */
//   long   ru_msgrcv;        /* IPC messages received */
//   long   ru_nsignals;      /* signals received */
//   long   ru_nvcsw;         /* voluntary context switches */
//   long   ru_nivcsw;        /* involuntary context switches */
//};

//struct timeval
//  {
//    long int tv_sec;       /* Seconds.  */
//    long int tv_usec;      /* Microseconds.  */
//  };


main () { 
    struct rusage buf; 
    // chew up some CPU time
    int i,j; for (i=0,j=0; i<100000000; i++) { j+=i*i; }     
    getrusage(RUSAGE_SELF, &buf); 
    printf("user seconds without microseconds: %ld\n", buf.ru_utime.tv_sec); 
    printf("user microseconds: %ld\n", buf.ru_utime.tv_usec); 
    printf("total user seconds: %e\n", 
       (double) buf.ru_utime.tv_sec 
     + (double) buf.ru_utime.tv_usec / (double) 1000000); 
}

Set time_t to milliseconds

2 Answers2

Linked