Overview of Time Related Data Structures and Functions in Unix/C. It s About Time

Transcription

1 Overview of Time Related Data Structures and Functions in Unix/C It s About Time 1. time_t Same as an unsigned long. Time in seconds since Midnight GMT Jan 1, a. char * ctime(time_t x) will return a string showing the current date and time. The string ends in a newline which you may want to get rid of. Also ctime_r. b. time_t time(time_t * x) will return the elapsed time in seconds since the EPOCH. c. time_t mktime(struct tm * brokendowntime) converts struct tm to time_t. d. struct tm * localtime(time_t * x) converts time_t to struct tm. Also localtime_r e. struct tm * gmtime(time_t *x) converts time_t to Grenwich England struct tm. Also gmtime_r; time_t is also used in struct timeval, struct itimerval, struct stat where it is used to represent the last accessed, modified and property change times, struct utmp where it is used to represent login, logout and system boot times. 2. struct timeval { time_t tv_sec; /* seconds */ suseconds_t tv_usec; /* microseconds */ Used when requiring a more precise time. Both values are unsigned long ints. The first is an EPOCH time. The second figure is in millionths of a second, however the clock that generated the value may not be that precise. Used in gettimeofday, settimeofday which access the system clock. settimeofday can only be run if you are root. There is no need for a function to convert a timeval to a time_t or the reverse. You just use the field tv_sec directly. 3. struct tm { int tm_sec; /* seconds */ int tm_min; /* minutes */

2 int tm_hour; /* hours */ int tm_mday; /* day of the month */ int tm_mon; /* month */ int tm_year; /* year */ int tm_wday; /* day of the week */ int tm_yday; /* day in the year */ int tm_isdst; /* daylight saving time */ This is know as broken down time because it is broken up into separate fields. The advantage of this format is that it corresponds to how human beings think of time. We can set, add or subtracts days, years, hours or minutes. Months are numbered Month 12 would be January of next year. Days are numbered 1 to 31 the 0 th day would be the last day of the previous month. The zeroth year is To store the year 2011 in the year field, subtract a) size_t strftime(char * result, size_t maxsize, char *format, struct tm * brokendt) - changes broken down time to a string, as specified by a date format. Returns the length of the returned string, 0 if the function fails. b) char * strptime(char * s, char * format, struct tm * brokendowntime) - scans a string and converts it to broken down time using a specified format. The return value points to the first character not processed by the function. c) see also time_t 4. char * timestring Time can be formated into a string using the function strftime( void *buffer,size_t n,char * fmt, struct tm * brokendowntime). The formats are the same as those used by the Unix date command. See man date for a full list. eg: strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M", &tm); If we know the format that a string was written with we can also convert a string into a broken down time using strptime(void *buffer,char *format, struct time * brokendowntime). This is useful when interpretting data from a form or when reading a file where the date has been reliably formatted by another program. If we wish to convert a time_t or a struct timeval value to a string we either use ctime or convert first to broken down time (struct tm). To go from a string to time_t there is no direct

3 route we need to go through another functions that use struct tm. 5. clock_t Measured in Jiffies. A Jiffy is one tick of the system clock. The number of jiffies per second is returned by the following system call: sysconf(clocks_per_sec). Jiffies are used to time processes. System clocks can run a different rates, depending on the machine. You can buy an add on card for your system that will give faster rates and a more precise time. a. clock_t clock() - returns number of clock ticks since the start of the process b. see also struct tms 6. struct tms { clock_t tms_utime; /* user time */ clock_t tms_stime; /* system time */ clock_t tms_cutime; /* user time of children */ clock_t tms_cstime; /* system time of children */ This is used with the Unix/C kernel function times(struct tms * buf). It s used to measure the elapsed execution time for a process. It s divided into 4 fields. The first 2 are for the current process, the second two are for any child processes spawned by your program. When you run the system or popen function you are starting a child process. Another way to do this is by using the fork() function which we will cover later. times measures CPU time. Time spent in the kernel is called stime or system time. Time executing outside the kernel is called utime or user time. To obtain the number of seconds of cpu time, take either the stime or the utime and divide by the # of jiffies per second. struct tms t; times(&t); usertime= ((double)t.utime)/sysconf(clocks_per_sec); Casting the utime to double is necessary otherwise you don t measure time that is less than 1 second.

4 User time is eaten up by normal calculation, manipulating strings, moving data around in arrays. System time is eaten up by privileged operations that require the kernel: file or network I/O, memory allocation and freeing, system security. The 3 rd type of time is called real, elapsed or wallclock time. When a process is running it may spend time waiting for keyboard input. Or it may be slowed down by other processes on the system. When a program is running slowing it is important to know which of these three times is the cause in order to make it run faster. If a task is bogged down in wallclock time, a faster processor won t help. One solution is to move other jobs off the system. If the cause is I/O, usually resulting in higher stime values, a faster drive may do more than a faster processor, or setting larger I/O buffers may be the answer. If the problem is utime, then a faster processor or a better algorithm is what should be considered. The Unix command line utility times is a wrapper function that will display all 3 times. times myprog --flags args The C kernel function with the same name times will only give you utime and stime. To get the elapse time you need to use gettimeofday. Function: a) clock_t times(struct tms *buf) - the returned value is the number of clock ticks since some time in the past we did not use this as the definition is not easy to use. buf contains the cpu times for the main process and the cumulative times for all child processes. 7. struct itimerval { struct timeval it_interval; /* next value */ struct timeval it_value; /* current value */ This data type is used to set a timer for a delay. Each of the fields is a timeval which has fields tv_secs and tv_usecs. The 2 nd field it_value represents the delay in seconds and microseconds until the first time signal is sent. The 1 st field it interval is used when you wish to repeat the alarm multiple times. If the fields of it_interval are set to zero the alarm is issued once.

5 Every process has 3 and only 3 alarm clocks. ITIMER_REAL is a real world time (wall clock time) timer. Using a) setitimerval(int which, struct itimerval *newval, struct itimerval *oldval) - sets a new timer. which is one of ITIMER_REAL (wallclock time), ITIMER_VIRTUAL (all cpu time) or ITIMER_PROF (kernel time). On completion SIGALRM, SIGVTALRM or SIGVTPROF is sent b) getitimerval(int which, struct itimerval * currentval) - retrives a current setting. c) sleep(int secs), usleep(int microsecs), alarm(int secs) all set up a real time alarm using setitimer. Summary There are functions to convert between time_t, struct tm and strings. struct timeval extends time_t to microseconds. These data structures are used to record absolute time relative to the EPOCH. You should know how to convert between these data types. struct timeval, clock_t and struct tms are all used to measure intervals, not absolute times. clock_t is converted to seconds by dividing the value by sysconf(_sc_clk_tck) (the number of clock ticks per second) and this can be converted using simple math (divide by 60) to minutes, hours or other units of time.