t/io_uring: fix bandwidth calculation
[fio.git] / time.c
1 #include <time.h>
2 #include <sys/time.h>
3
4 #include "fio.h"
5
6 static struct timespec genesis;
7 static unsigned long ns_granularity;
8
9 void timespec_add_msec(struct timespec *ts, unsigned int msec)
10 {
11         uint64_t adj_nsec = 1000000ULL * msec;
12
13         ts->tv_nsec += adj_nsec;
14         if (adj_nsec >= 1000000000) {
15                 uint64_t adj_sec = adj_nsec / 1000000000;
16
17                 ts->tv_nsec -= adj_sec * 1000000000;
18                 ts->tv_sec += adj_sec;
19         }
20         if (ts->tv_nsec >= 1000000000){
21                 ts->tv_nsec -= 1000000000;
22                 ts->tv_sec++;
23         }
24 }
25
26 /*
27  * busy looping version for the last few usec
28  */
29 uint64_t usec_spin(unsigned int usec)
30 {
31         struct timespec start;
32         uint64_t t;
33
34         fio_gettime(&start, NULL);
35         while ((t = utime_since_now(&start)) < usec)
36                 nop;
37
38         return t;
39 }
40
41 uint64_t usec_sleep(struct thread_data *td, unsigned long usec)
42 {
43         struct timespec req;
44         struct timespec tv;
45         uint64_t t = 0;
46
47         do {
48                 unsigned long ts = usec;
49
50                 if (usec < ns_granularity) {
51                         t += usec_spin(usec);
52                         break;
53                 }
54
55                 ts = usec - ns_granularity;
56
57                 if (ts >= 1000000) {
58                         req.tv_sec = ts / 1000000;
59                         ts -= 1000000 * req.tv_sec;
60                         /*
61                          * Limit sleep to ~1 second at most, otherwise we
62                          * don't notice then someone signaled the job to
63                          * exit manually.
64                          */
65                         if (req.tv_sec > 1)
66                                 req.tv_sec = 1;
67                 } else
68                         req.tv_sec = 0;
69
70                 req.tv_nsec = ts * 1000;
71                 fio_gettime(&tv, NULL);
72
73                 if (nanosleep(&req, NULL) < 0)
74                         break;
75
76                 ts = utime_since_now(&tv);
77                 t += ts;
78                 if (ts >= usec)
79                         break;
80
81                 usec -= ts;
82         } while (!td->terminate);
83
84         return t;
85 }
86
87 uint64_t time_since_genesis(void)
88 {
89         return time_since_now(&genesis);
90 }
91
92 uint64_t mtime_since_genesis(void)
93 {
94         return mtime_since_now(&genesis);
95 }
96
97 uint64_t utime_since_genesis(void)
98 {
99         return utime_since_now(&genesis);
100 }
101
102 bool in_ramp_time(struct thread_data *td)
103 {
104         return td->o.ramp_time && !td->ramp_time_over;
105 }
106
107 static bool parent_update_ramp(struct thread_data *td)
108 {
109         struct thread_data *parent = td->parent;
110
111         if (!parent || parent->ramp_time_over)
112                 return false;
113
114         reset_all_stats(parent);
115         parent->ramp_time_over = true;
116         td_set_runstate(parent, TD_RAMP);
117         return true;
118 }
119
120 bool ramp_time_over(struct thread_data *td)
121 {
122         if (!td->o.ramp_time || td->ramp_time_over)
123                 return true;
124
125         if (utime_since_now(&td->epoch) >= td->o.ramp_time) {
126                 td->ramp_time_over = true;
127                 reset_all_stats(td);
128                 reset_io_stats(td);
129                 td_set_runstate(td, TD_RAMP);
130
131                 /*
132                  * If we have a parent, the parent isn't doing IO. Hence
133                  * the parent never enters do_io(), which will switch us
134                  * from RAMP -> RUNNING. Do this manually here.
135                  */
136                 if (parent_update_ramp(td))
137                         td_set_runstate(td, TD_RUNNING);
138
139                 return true;
140         }
141
142         return false;
143 }
144
145 void fio_time_init(void)
146 {
147         int i;
148
149         fio_clock_init();
150
151         /*
152          * Check the granularity of the nanosleep function
153          */
154         for (i = 0; i < 10; i++) {
155                 struct timespec tv, ts;
156                 unsigned long elapsed;
157
158                 fio_gettime(&tv, NULL);
159                 ts.tv_sec = 0;
160                 ts.tv_nsec = 1000;
161
162                 nanosleep(&ts, NULL);
163                 elapsed = utime_since_now(&tv);
164
165                 if (elapsed > ns_granularity)
166                         ns_granularity = elapsed;
167         }
168 }
169
170 void set_genesis_time(void)
171 {
172         fio_gettime(&genesis, NULL);
173 }
174
175 void set_epoch_time(struct thread_data *td, int log_unix_epoch)
176 {
177         fio_gettime(&td->epoch, NULL);
178         if (log_unix_epoch) {
179                 struct timeval tv;
180                 gettimeofday(&tv, NULL);
181                 td->unix_epoch = (unsigned long long)(tv.tv_sec) * 1000 +
182                                  (unsigned long long)(tv.tv_usec) / 1000;
183         }
184 }
185
186 void fill_start_time(struct timespec *t)
187 {
188         memcpy(t, &genesis, sizeof(genesis));
189 }