blob: a63968ad40c9b6e935df5171d83b8303632007d7 [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
2 * Time calculation functions.
3 *
Willy Tarreau45a12512011-09-10 16:56:42 +02004 * Copyright 2000-2011 Willy Tarreau <w@1wt.eu>
Willy Tarreaubaaee002006-06-26 02:48:02 +02005 *
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>
Willy Tarreaue3ba5f02006-06-29 18:54:54 +020014
15#include <common/config.h>
Willy Tarreau5e8f0662007-02-12 00:59:08 +010016#include <common/standard.h>
Willy Tarreau2dd0d472006-06-29 17:53:05 +020017#include <common/time.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020018
Willy Tarreaueab777c2012-12-29 21:50:07 +010019unsigned int ms_left_scaled; /* milliseconds left for current second (0..2^32-1) */
Willy Tarreaue6313a32008-06-29 13:47:25 +020020unsigned int now_ms; /* internal date in milliseconds (may wrap) */
Willy Tarreau45a12512011-09-10 16:56:42 +020021unsigned int samp_time; /* total elapsed time over current sample */
22unsigned int idle_time; /* total idle time over current sample */
23unsigned int idle_pct; /* idle to total ratio over last sample (percent) */
Willy Tarreaub7f694f2008-06-22 17:18:02 +020024struct timeval now; /* internal date is a monotonic function of real clock */
25struct timeval date; /* the real current date */
Willy Tarreaubaaee002006-06-26 02:48:02 +020026struct timeval start_date; /* the process's start date */
Willy Tarreau45a12512011-09-10 16:56:42 +020027struct timeval before_poll; /* system date before calling poll() */
28struct timeval after_poll; /* system date after leaving poll() */
Willy Tarreaubaaee002006-06-26 02:48:02 +020029
30/*
31 * adds <ms> ms to <from>, set the result to <tv> and returns a pointer <tv>
32 */
Willy Tarreau42aae5c2007-04-29 17:43:56 +020033REGPRM3 struct timeval *_tv_ms_add(struct timeval *tv, const struct timeval *from, int ms)
Willy Tarreaubaaee002006-06-26 02:48:02 +020034{
Willy Tarreau42aae5c2007-04-29 17:43:56 +020035 tv->tv_usec = from->tv_usec + (ms % 1000) * 1000;
36 tv->tv_sec = from->tv_sec + (ms / 1000);
Willy Tarreaubaaee002006-06-26 02:48:02 +020037 while (tv->tv_usec >= 1000000) {
38 tv->tv_usec -= 1000000;
39 tv->tv_sec++;
40 }
41 return tv;
42}
43
44/*
45 * compares <tv1> and <tv2> modulo 1ms: returns 0 if equal, -1 if tv1 < tv2, 1 if tv1 > tv2
Willy Tarreau42aae5c2007-04-29 17:43:56 +020046 * Must not be used when either argument is eternity. Use tv_ms_cmp2() for that.
Willy Tarreaubaaee002006-06-26 02:48:02 +020047 */
Willy Tarreau42aae5c2007-04-29 17:43:56 +020048REGPRM2 int _tv_ms_cmp(const struct timeval *tv1, const struct timeval *tv2)
Willy Tarreaubaaee002006-06-26 02:48:02 +020049{
Willy Tarreau42aae5c2007-04-29 17:43:56 +020050 return __tv_ms_cmp(tv1, tv2);
Willy Tarreaubaaee002006-06-26 02:48:02 +020051}
52
53/*
Willy Tarreaubaaee002006-06-26 02:48:02 +020054 * compares <tv1> and <tv2> modulo 1 ms: returns 0 if equal, -1 if tv1 < tv2, 1 if tv1 > tv2,
Willy Tarreaua6a6a932007-04-28 22:40:08 +020055 * assuming that TV_ETERNITY is greater than everything.
Willy Tarreaubaaee002006-06-26 02:48:02 +020056 */
Willy Tarreau42aae5c2007-04-29 17:43:56 +020057REGPRM2 int _tv_ms_cmp2(const struct timeval *tv1, const struct timeval *tv2)
Willy Tarreaubaaee002006-06-26 02:48:02 +020058{
Willy Tarreau42aae5c2007-04-29 17:43:56 +020059 return __tv_ms_cmp2(tv1, tv2);
Willy Tarreau8d7d1492007-04-29 10:50:43 +020060}
61
62/*
63 * compares <tv1> and <tv2> modulo 1 ms: returns 1 if tv1 <= tv2, 0 if tv1 > tv2,
64 * assuming that TV_ETERNITY is greater than everything. Returns 0 if tv1 is
65 * TV_ETERNITY, and always assumes that tv2 != TV_ETERNITY. Designed to replace
Willy Tarreau42aae5c2007-04-29 17:43:56 +020066 * occurrences of (tv_ms_cmp2(tv,now) <= 0).
Willy Tarreau8d7d1492007-04-29 10:50:43 +020067 */
Willy Tarreau42aae5c2007-04-29 17:43:56 +020068REGPRM2 int _tv_ms_le2(const struct timeval *tv1, const struct timeval *tv2)
Willy Tarreau8d7d1492007-04-29 10:50:43 +020069{
Willy Tarreau42aae5c2007-04-29 17:43:56 +020070 return __tv_ms_le2(tv1, tv2);
71}
Willy Tarreau8d7d1492007-04-29 10:50:43 +020072
Willy Tarreau42aae5c2007-04-29 17:43:56 +020073/*
74 * returns the remaining time between tv1=now and event=tv2
75 * if tv2 is passed, 0 is returned.
76 * Must not be used when either argument is eternity.
77 */
78REGPRM2 unsigned long _tv_ms_remain(const struct timeval *tv1, const struct timeval *tv2)
79{
80 return __tv_ms_remain(tv1, tv2);
Willy Tarreaubaaee002006-06-26 02:48:02 +020081}
82
83/*
84 * returns the remaining time between tv1=now and event=tv2
85 * if tv2 is passed, 0 is returned.
86 * Returns TIME_ETERNITY if tv2 is eternity.
87 */
Willy Tarreau42aae5c2007-04-29 17:43:56 +020088REGPRM2 unsigned long _tv_ms_remain2(const struct timeval *tv1, const struct timeval *tv2)
Willy Tarreaubaaee002006-06-26 02:48:02 +020089{
Willy Tarreaubaaee002006-06-26 02:48:02 +020090 if (tv_iseternity(tv2))
91 return TIME_ETERNITY;
92
Willy Tarreau42aae5c2007-04-29 17:43:56 +020093 return __tv_ms_remain(tv1, tv2);
Willy Tarreaubaaee002006-06-26 02:48:02 +020094}
95
Willy Tarreaubaaee002006-06-26 02:48:02 +020096/*
Willy Tarreau42aae5c2007-04-29 17:43:56 +020097 * Returns the time in ms elapsed between tv1 and tv2, assuming that tv1<=tv2.
Willy Tarreaubaaee002006-06-26 02:48:02 +020098 * Must not be used when either argument is eternity.
99 */
Willy Tarreau42aae5c2007-04-29 17:43:56 +0200100REGPRM2 unsigned long _tv_ms_elapsed(const struct timeval *tv1, const struct timeval *tv2)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200101{
Willy Tarreau42aae5c2007-04-29 17:43:56 +0200102 return __tv_ms_elapsed(tv1, tv2);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200103}
104
105/*
Willy Tarreaud825eef2007-05-12 22:35:00 +0200106 * adds <inc> to <from>, set the result to <tv> and returns a pointer <tv>
107 */
108REGPRM3 struct timeval *_tv_add(struct timeval *tv, const struct timeval *from, const struct timeval *inc)
109{
110 return __tv_add(tv, from, inc);
111}
112
113/*
Willy Tarreau0481c202007-05-13 16:03:27 +0200114 * If <inc> is set, then add it to <from> and set the result to <tv>, then
115 * return 1, otherwise return 0. It is meant to be used in if conditions.
116 */
117REGPRM3 int _tv_add_ifset(struct timeval *tv, const struct timeval *from, const struct timeval *inc)
118{
119 return __tv_add_ifset(tv, from, inc);
120}
121
122/*
Willy Tarreaud825eef2007-05-12 22:35:00 +0200123 * Computes the remaining time between tv1=now and event=tv2. if tv2 is passed,
124 * 0 is returned. The result is stored into tv.
125 */
126REGPRM3 struct timeval *_tv_remain(const struct timeval *tv1, const struct timeval *tv2, struct timeval *tv)
127{
128 return __tv_remain(tv1, tv2, tv);
129}
130
131/*
132 * Computes the remaining time between tv1=now and event=tv2. if tv2 is passed,
133 * 0 is returned. The result is stored into tv. Returns ETERNITY if tv2 is
134 * eternity.
135 */
136REGPRM3 struct timeval *_tv_remain2(const struct timeval *tv1, const struct timeval *tv2, struct timeval *tv)
137{
138 return __tv_remain2(tv1, tv2, tv);
139}
140
Willy Tarreau0481c202007-05-13 16:03:27 +0200141/* tv_isle: compares <tv1> and <tv2> : returns 1 if tv1 <= tv2, otherwise 0 */
142REGPRM2 int _tv_isle(const struct timeval *tv1, const struct timeval *tv2)
143{
144 return __tv_isle(tv1, tv2);
145}
146
147/* tv_isgt: compares <tv1> and <tv2> : returns 1 if tv1 > tv2, otherwise 0 */
148REGPRM2 int _tv_isgt(const struct timeval *tv1, const struct timeval *tv2)
149{
150 return __tv_isgt(tv1, tv2);
151}
152
Willy Tarreaub0b37bc2008-06-23 14:00:57 +0200153/* tv_udpate_date: sets <date> to system time, and sets <now> to something as
154 * close as possible to real time, following a monotonic function. The main
155 * principle consists in detecting backwards and forwards time jumps and adjust
156 * an offset to correct them. This function should be called once after each
157 * poll, and never farther apart than MAX_DELAY_MS*2. The poll's timeout should
158 * be passed in <max_wait>, and the return value in <interrupted> (a non-zero
159 * value means that we have not expired the timeout). Calling it with (-1,*)
160 * sets both <date> and <now> to current date, and calling it with (0,1) simply
161 * updates the values.
Willy Tarreaub7f694f2008-06-22 17:18:02 +0200162 */
Willy Tarreaub0b37bc2008-06-23 14:00:57 +0200163REGPRM2 void tv_update_date(int max_wait, int interrupted)
Willy Tarreaub7f694f2008-06-22 17:18:02 +0200164{
Willy Tarreaub0b37bc2008-06-23 14:00:57 +0200165 static struct timeval tv_offset; /* warning: signed offset! */
166 struct timeval adjusted, deadline;
Willy Tarreau351b3a12017-03-29 15:24:33 +0200167 unsigned int curr_sec_ms; /* millisecond of current second (0..999) */
Willy Tarreaub7f694f2008-06-22 17:18:02 +0200168
Willy Tarreaub0b37bc2008-06-23 14:00:57 +0200169 gettimeofday(&date, NULL);
170 if (unlikely(max_wait < 0)) {
171 tv_zero(&tv_offset);
Willy Tarreau75590582009-03-05 14:54:50 +0100172 adjusted = date;
Willy Tarreau45a12512011-09-10 16:56:42 +0200173 after_poll = date;
174 samp_time = idle_time = 0;
175 idle_pct = 100;
Willy Tarreaue6313a32008-06-29 13:47:25 +0200176 goto to_ms;
Willy Tarreaub0b37bc2008-06-23 14:00:57 +0200177 }
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);
Willy Tarreau75590582009-03-05 14:54:50 +0100188 if (likely(__tv_islt(&adjusted, &deadline)))
189 goto to_ms; /* OK time is within expected range */
Willy Tarreaub0b37bc2008-06-23 14:00:57 +0200190 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 */
Willy Tarreau75590582009-03-05 14:54:50 +0100195 _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;
Willy Tarreaub0b37bc2008-06-23 14:00:57 +0200199 if (tv_offset.tv_usec < 0) {
200 tv_offset.tv_usec += 1000000;
201 tv_offset.tv_sec--;
Willy Tarreaub7f694f2008-06-22 17:18:02 +0200202 }
Willy Tarreaue6313a32008-06-29 13:47:25 +0200203 to_ms:
Willy Tarreau75590582009-03-05 14:54:50 +0100204 now = adjusted;
205 curr_sec_ms = now.tv_usec / 1000; /* ms of current second */
Willy Tarreaueab777c2012-12-29 21:50:07 +0100206
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;
Willy Tarreau75590582009-03-05 14:54:50 +0100217 now_ms = now.tv_sec * 1000 + curr_sec_ms;
Willy Tarreaub0b37bc2008-06-23 14:00:57 +0200218 return;
Willy Tarreaub7f694f2008-06-22 17:18:02 +0200219}
220
Willy Tarreaud825eef2007-05-12 22:35:00 +0200221/*
Willy Tarreaubaaee002006-06-26 02:48:02 +0200222 * Local variables:
223 * c-indent-level: 8
224 * c-basic-offset: 8
225 * End:
226 */