1 /*
2 * Time calculation functions.
3 *
4 * Copyright 2000-2011 Willy Tarreau <w@1wt.eu>
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
13 #include <sys/time.h>
14
15 #include <common/config.h>
16 #include <common/standard.h>
17 #include <common/time.h>
18
19 unsigned int curr_sec_ms; /* millisecond of current second (0..999) */
20 unsigned int ms_left_scaled; /* milliseconds left for current second (0..2^32-1) */
21 unsigned int now_ms; /* internal date in milliseconds (may wrap) */
22 unsigned int samp_time; /* total elapsed time over current sample */
23 unsigned int idle_time; /* total idle time over current sample */
24 unsigned int idle_pct; /* idle to total ratio over last sample (percent) */
25 struct timeval now; /* internal date is a monotonic function of real clock */
26 struct timeval date; /* the real current date */
27 struct timeval start_date; /* the process's start date */
28 struct timeval before_poll; /* system date before calling poll() */
29 struct timeval after_poll; /* system date after leaving poll() */
30
31 /*
32 * adds <ms> ms to <from>, set the result to <tv> and returns a pointer <tv>
33 */
_tv_ms_add(struct timeval * tv,const struct timeval * from,int ms)34 REGPRM3 struct timeval *_tv_ms_add(struct timeval *tv, const struct timeval *from, int ms)
35 {
36 tv->tv_usec = from->tv_usec + (ms % 1000) * 1000;
37 tv->tv_sec = from->tv_sec + (ms / 1000);
38 while (tv->tv_usec >= 1000000) {
39 tv->tv_usec -= 1000000;
40 tv->tv_sec++;
41 }
42 return tv;
43 }
44
45 /*
46 * compares <tv1> and <tv2> modulo 1ms: returns 0 if equal, -1 if tv1 < tv2, 1 if tv1 > tv2
47 * Must not be used when either argument is eternity. Use tv_ms_cmp2() for that.
48 */
_tv_ms_cmp(const struct timeval * tv1,const struct timeval * tv2)49 REGPRM2 int _tv_ms_cmp(const struct timeval *tv1, const struct timeval *tv2)
50 {
51 return __tv_ms_cmp(tv1, tv2);
52 }
53
54 /*
55 * compares <tv1> and <tv2> modulo 1 ms: returns 0 if equal, -1 if tv1 < tv2, 1 if tv1 > tv2,
56 * assuming that TV_ETERNITY is greater than everything.
57 */
_tv_ms_cmp2(const struct timeval * tv1,const struct timeval * tv2)58 REGPRM2 int _tv_ms_cmp2(const struct timeval *tv1, const struct timeval *tv2)
59 {
60 return __tv_ms_cmp2(tv1, tv2);
61 }
62
63 /*
64 * compares <tv1> and <tv2> modulo 1 ms: returns 1 if tv1 <= tv2, 0 if tv1 > tv2,
65 * assuming that TV_ETERNITY is greater than everything. Returns 0 if tv1 is
66 * TV_ETERNITY, and always assumes that tv2 != TV_ETERNITY. Designed to replace
67 * occurrences of (tv_ms_cmp2(tv,now) <= 0).
68 */
_tv_ms_le2(const struct timeval * tv1,const struct timeval * tv2)69 REGPRM2 int _tv_ms_le2(const struct timeval *tv1, const struct timeval *tv2)
70 {
71 return __tv_ms_le2(tv1, tv2);
72 }
73
74 /*
75 * returns the remaining time between tv1=now and event=tv2
76 * if tv2 is passed, 0 is returned.
77 * Must not be used when either argument is eternity.
78 */
_tv_ms_remain(const struct timeval * tv1,const struct timeval * tv2)79 REGPRM2 unsigned long _tv_ms_remain(const struct timeval *tv1, const struct timeval *tv2)
80 {
81 return __tv_ms_remain(tv1, tv2);
82 }
83
84 /*
85 * returns the remaining time between tv1=now and event=tv2
86 * if tv2 is passed, 0 is returned.
87 * Returns TIME_ETERNITY if tv2 is eternity.
88 */
_tv_ms_remain2(const struct timeval * tv1,const struct timeval * tv2)89 REGPRM2 unsigned long _tv_ms_remain2(const struct timeval *tv1, const struct timeval *tv2)
90 {
91 if (tv_iseternity(tv2))
92 return TIME_ETERNITY;
93
94 return __tv_ms_remain(tv1, tv2);
95 }
96
97 /*
98 * Returns the time in ms elapsed between tv1 and tv2, assuming that tv1<=tv2.
99 * Must not be used when either argument is eternity.
100 */
_tv_ms_elapsed(const struct timeval * tv1,const struct timeval * tv2)101 REGPRM2 unsigned long _tv_ms_elapsed(const struct timeval *tv1, const struct timeval *tv2)
102 {
103 return __tv_ms_elapsed(tv1, tv2);
104 }
105
106 /*
107 * adds <inc> to <from>, set the result to <tv> and returns a pointer <tv>
108 */
_tv_add(struct timeval * tv,const struct timeval * from,const struct timeval * inc)109 REGPRM3 struct timeval *_tv_add(struct timeval *tv, const struct timeval *from, const struct timeval *inc)
110 {
111 return __tv_add(tv, from, inc);
112 }
113
114 /*
115 * If <inc> is set, then add it to <from> and set the result to <tv>, then
116 * return 1, otherwise return 0. It is meant to be used in if conditions.
117 */
_tv_add_ifset(struct timeval * tv,const struct timeval * from,const struct timeval * inc)118 REGPRM3 int _tv_add_ifset(struct timeval *tv, const struct timeval *from, const struct timeval *inc)
119 {
120 return __tv_add_ifset(tv, from, inc);
121 }
122
123 /*
124 * Computes the remaining time between tv1=now and event=tv2. if tv2 is passed,
125 * 0 is returned. The result is stored into tv.
126 */
_tv_remain(const struct timeval * tv1,const struct timeval * tv2,struct timeval * tv)127 REGPRM3 struct timeval *_tv_remain(const struct timeval *tv1, const struct timeval *tv2, struct timeval *tv)
128 {
129 return __tv_remain(tv1, tv2, tv);
130 }
131
132 /*
133 * Computes the remaining time between tv1=now and event=tv2. if tv2 is passed,
134 * 0 is returned. The result is stored into tv. Returns ETERNITY if tv2 is
135 * eternity.
136 */
_tv_remain2(const struct timeval * tv1,const struct timeval * tv2,struct timeval * tv)137 REGPRM3 struct timeval *_tv_remain2(const struct timeval *tv1, const struct timeval *tv2, struct timeval *tv)
138 {
139 return __tv_remain2(tv1, tv2, tv);
140 }
141
142 /* tv_isle: compares <tv1> and <tv2> : returns 1 if tv1 <= tv2, otherwise 0 */
_tv_isle(const struct timeval * tv1,const struct timeval * tv2)143 REGPRM2 int _tv_isle(const struct timeval *tv1, const struct timeval *tv2)
144 {
145 return __tv_isle(tv1, tv2);
146 }
147
148 /* tv_isgt: compares <tv1> and <tv2> : returns 1 if tv1 > tv2, otherwise 0 */
_tv_isgt(const struct timeval * tv1,const struct timeval * tv2)149 REGPRM2 int _tv_isgt(const struct timeval *tv1, const struct timeval *tv2)
150 {
151 return __tv_isgt(tv1, tv2);
152 }
153
154 /* tv_udpate_date: sets <date> to system time, and sets <now> to something as
155 * close as possible to real time, following a monotonic function. The main
156 * principle consists in detecting backwards and forwards time jumps and adjust
157 * an offset to correct them. This function should be called once after each
158 * poll, and never farther apart than MAX_DELAY_MS*2. The poll's timeout should
159 * be passed in <max_wait>, and the return value in <interrupted> (a non-zero
160 * value means that we have not expired the timeout). Calling it with (-1,*)
161 * sets both <date> and <now> to current date, and calling it with (0,1) simply
162 * updates the values.
163 */
tv_update_date(int max_wait,int interrupted)164 REGPRM2 void tv_update_date(int max_wait, int interrupted)
165 {
166 static struct timeval tv_offset; /* warning: signed offset! */
167 struct timeval adjusted, deadline;
168
169 gettimeofday(&date, NULL);
170 if (unlikely(max_wait < 0)) {
171 tv_zero(&tv_offset);
172 adjusted = date;
173 after_poll = date;
174 samp_time = idle_time = 0;
175 idle_pct = 100;
176 goto to_ms;
177 }
178 __tv_add(&adjusted, &date, &tv_offset);
179 if (unlikely(__tv_islt(&adjusted, &now))) {
180 goto fixup; /* jump in the past */
181 }
182
183 /* OK we did not jump backwards, let's see if we have jumped too far
184 * forwards. The poll value was in <max_wait>, we accept that plus
185 * MAX_DELAY_MS to cover additional time.
186 */
187 _tv_ms_add(&deadline, &now, max_wait + MAX_DELAY_MS);
188 if (likely(__tv_islt(&adjusted, &deadline)))
189 goto to_ms; /* OK time is within expected range */
190 fixup:
191 /* Large jump. If the poll was interrupted, we consider that the date
192 * has not changed (immediate wake-up), otherwise we add the poll
193 * time-out to the previous date. The new offset is recomputed.
194 */
195 _tv_ms_add(&adjusted, &now, interrupted ? 0 : max_wait);
196
197 tv_offset.tv_sec = adjusted.tv_sec - date.tv_sec;
198 tv_offset.tv_usec = adjusted.tv_usec - date.tv_usec;
199 if (tv_offset.tv_usec < 0) {
200 tv_offset.tv_usec += 1000000;
201 tv_offset.tv_sec--;
202 }
203 to_ms:
204 now = adjusted;
205 curr_sec_ms = now.tv_usec / 1000; /* ms of current second */
206
207 /* For frequency counters, we'll need to know the ratio of the previous
208 * value to add to current value depending on the current millisecond.
209 * The principle is that during the first millisecond, we use 999/1000
210 * of the past value and that during the last millisecond we use 0/1000
211 * of the past value. In summary, we only use the past value during the
212 * first 999 ms of a second, and the last ms is used to complete the
213 * current measure. The value is scaled to (2^32-1) so that a simple
214 * multiply followed by a shift gives us the final value.
215 */
216 ms_left_scaled = (999U - curr_sec_ms) * 4294967U;
217 now_ms = now.tv_sec * 1000 + curr_sec_ms;
218 return;
219 }
220
221 /*
222 * Local variables:
223 * c-indent-level: 8
224 * c-basic-offset: 8
225 * End:
226 */
227