Add support for reserved keywords
[fio.git] / eta.c
CommitLineData
263e529f
JA
1/*
2 * Status and ETA code
3 */
4#include <unistd.h>
5#include <fcntl.h>
6#include <string.h>
7
8#include "fio.h"
263e529f
JA
9
10static char run_str[MAX_JOBS + 1];
11
12/*
13 * Sets the status of the 'td' in the printed status map.
14 */
15static void check_str_update(struct thread_data *td)
16{
17 char c = run_str[td->thread_number - 1];
18
19 switch (td->runstate) {
5ec10eaa
JA
20 case TD_REAPED:
21 c = '_';
22 break;
23 case TD_EXITED:
24 c = 'E';
25 break;
b29ee5b3
JA
26 case TD_RAMP:
27 c = '/';
28 break;
5ec10eaa
JA
29 case TD_RUNNING:
30 if (td_rw(td)) {
31 if (td_random(td))
32 c = 'm';
33 else
34 c = 'M';
35 } else if (td_read(td)) {
36 if (td_random(td))
37 c = 'r';
38 else
39 c = 'R';
40 } else {
41 if (td_random(td))
42 c = 'w';
43 else
44 c = 'W';
45 }
46 break;
b0f65863
JA
47 case TD_PRE_READING:
48 c = 'p';
49 break;
5ec10eaa
JA
50 case TD_VERIFYING:
51 c = 'V';
52 break;
53 case TD_FSYNCING:
54 c = 'F';
55 break;
56 case TD_CREATED:
57 c = 'C';
58 break;
59 case TD_INITIALIZED:
60 c = 'I';
61 break;
62 case TD_NOT_CREATED:
63 c = 'P';
64 break;
65 default:
66 log_err("state %d\n", td->runstate);
263e529f
JA
67 }
68
69 run_str[td->thread_number - 1] = c;
70}
71
72/*
73 * Convert seconds to a printable string.
74 */
9c02f6ef 75static void eta_to_str(char *str, unsigned long eta_sec)
263e529f
JA
76{
77 unsigned int d, h, m, s;
165faf16 78 int disp_hour = 0;
263e529f 79
263e529f
JA
80 s = eta_sec % 60;
81 eta_sec /= 60;
82 m = eta_sec % 60;
83 eta_sec /= 60;
84 h = eta_sec % 24;
85 eta_sec /= 24;
86 d = eta_sec;
87
165faf16
JA
88 if (d) {
89 disp_hour = 1;
1e97cce9 90 str += sprintf(str, "%02ud:", d);
263e529f 91 }
165faf16
JA
92
93 if (h || disp_hour)
1e97cce9 94 str += sprintf(str, "%02uh:", h);
263e529f 95
1e97cce9
JA
96 str += sprintf(str, "%02um:", m);
97 str += sprintf(str, "%02us", s);
263e529f
JA
98}
99
100/*
101 * Best effort calculation of the estimated pending runtime of a job.
102 */
b29ee5b3 103static int thread_eta(struct thread_data *td)
263e529f
JA
104{
105 unsigned long long bytes_total, bytes_done;
1e97cce9 106 unsigned long eta_sec = 0;
b29ee5b3
JA
107 unsigned long elapsed;
108
109 elapsed = (mtime_since_now(&td->epoch) + 999) / 1000;
263e529f
JA
110
111 bytes_total = td->total_io_size;
112
74939e38
JA
113 /*
114 * if writing, bytes_total will be twice the size. If mixing,
115 * assume a 50/50 split and thus bytes_total will be 50% larger.
116 */
0dd8377f 117 if (td->o.do_verify && td->o.verify && td_write(td)) {
74939e38
JA
118 if (td_rw(td))
119 bytes_total = bytes_total * 3 / 2;
120 else
121 bytes_total <<= 1;
122 }
123
2dc1bbeb
JA
124 if (td->o.zone_size && td->o.zone_skip)
125 bytes_total /= (td->o.zone_skip / td->o.zone_size);
263e529f 126
9c5a3854
SSY
127 if (td->o.fill_device && td->o.size == -1ULL)
128 return 0;
129
263e529f 130 if (td->runstate == TD_RUNNING || td->runstate == TD_VERIFYING) {
cf4464ca 131 double perc, perc_t;
263e529f
JA
132
133 bytes_done = td->io_bytes[DDIR_READ] + td->io_bytes[DDIR_WRITE];
134 perc = (double) bytes_done / (double) bytes_total;
135 if (perc > 1.0)
136 perc = 1.0;
137
cf4464ca
JA
138 if (td->o.time_based) {
139 perc_t = (double) elapsed / (double) td->o.timeout;
140 if (perc_t < perc)
141 perc = perc_t;
142 }
143
1e97cce9 144 eta_sec = (unsigned long) (elapsed * (1.0 / perc)) - elapsed;
263e529f 145
d3eeeabc
JA
146 if (td->o.timeout &&
147 eta_sec > (td->o.timeout + done_secs - elapsed))
148 eta_sec = td->o.timeout + done_secs - elapsed;
263e529f 149 } else if (td->runstate == TD_NOT_CREATED || td->runstate == TD_CREATED
b29ee5b3 150 || td->runstate == TD_INITIALIZED
b0f65863
JA
151 || td->runstate == TD_RAMP
152 || td->runstate == TD_PRE_READING) {
263e529f
JA
153 int t_eta = 0, r_eta = 0;
154
155 /*
156 * We can only guess - assume it'll run the full timeout
157 * if given, otherwise assume it'll run at the specified rate.
158 */
b29ee5b3 159 if (td->o.timeout) {
d3eeeabc 160 t_eta = td->o.timeout + td->o.start_delay;
b29ee5b3
JA
161
162 if (in_ramp_time(td)) {
163 unsigned long ramp_left;
164
165 ramp_left = mtime_since_now(&td->start);
166 ramp_left = (ramp_left + 999) / 1000;
167 if (ramp_left <= t_eta)
168 t_eta -= ramp_left;
169 }
170 }
581e7141
JA
171 if (td->o.rate[0] || td->o.rate[1]) {
172 r_eta = (bytes_total / 1024) / (td->o.rate[0] + td->o.rate[1]);
d3eeeabc 173 r_eta += td->o.start_delay;
263e529f
JA
174 }
175
176 if (r_eta && t_eta)
177 eta_sec = min(r_eta, t_eta);
178 else if (r_eta)
179 eta_sec = r_eta;
180 else if (t_eta)
181 eta_sec = t_eta;
182 else
183 eta_sec = 0;
184 } else {
185 /*
186 * thread is already done or waiting for fsync
187 */
188 eta_sec = 0;
189 }
190
191 return eta_sec;
192}
193
46fda8d0
JA
194static void calc_rate(unsigned long mtime, unsigned long long *io_bytes,
195 unsigned long long *prev_io_bytes, unsigned int *rate)
196{
197 rate[0] = (io_bytes[0] - prev_io_bytes[0]) / mtime;
198 rate[1] = (io_bytes[1] - prev_io_bytes[1]) / mtime;
199 prev_io_bytes[0] = io_bytes[0];
200 prev_io_bytes[1] = io_bytes[1];
201}
5ec10eaa 202
adb02ba8
JA
203static void calc_iops(unsigned long mtime, unsigned long long *io_iops,
204 unsigned long long *prev_io_iops, unsigned int *iops)
205{
206 iops[0] = ((io_iops[0] - prev_io_iops[0]) * 1000) / mtime;
207 iops[1] = ((io_iops[1] - prev_io_iops[1]) * 1000) / mtime;
208 prev_io_iops[0] = io_iops[0];
209 prev_io_iops[1] = io_iops[1];
210}
211
263e529f
JA
212/*
213 * Print status of the jobs we know about. This includes rate estimates,
214 * ETA, thread state, etc.
215 */
216void print_thread_status(void)
217{
b29ee5b3
JA
218 unsigned long elapsed = (mtime_since_genesis() + 999) / 1000;
219 int i, nr_ramp, nr_running, nr_pending, t_rate, m_rate;
e6e41602 220 int t_iops, m_iops, files_open;
34572e28 221 struct thread_data *td;
2eaa41ce 222 char eta_str[128];
263e529f 223 double perc = 0.0;
adb02ba8 224 unsigned long long io_bytes[2], io_iops[2];
d3eeeabc 225 unsigned long rate_time, disp_time, bw_avg_time, *eta_secs, eta_sec;
46fda8d0
JA
226 struct timeval now;
227
228 static unsigned long long rate_io_bytes[2];
229 static unsigned long long disp_io_bytes[2];
adb02ba8 230 static unsigned long long disp_io_iops[2];
46fda8d0 231 static struct timeval rate_prev_time, disp_prev_time;
adb02ba8 232 static unsigned int rate[2], iops[2];
43819609 233 static int linelen_last;
cac58fd5 234 static int eta_good;
d6978a32 235 int i2p = 0;
6043c579 236
e592a06b
AC
237 if (temp_stall_ts || terse_output || eta_print == FIO_ETA_NEVER)
238 return;
239
240 if (!isatty(STDOUT_FILENO) && (eta_print != FIO_ETA_ALWAYS))
263e529f
JA
241 return;
242
46fda8d0
JA
243 if (!rate_io_bytes[0] && !rate_io_bytes[1])
244 fill_start_time(&rate_prev_time);
245 if (!disp_io_bytes[0] && !disp_io_bytes[1])
246 fill_start_time(&disp_prev_time);
6043c579 247
d3eeeabc
JA
248 eta_secs = malloc(thread_number * sizeof(unsigned long));
249 memset(eta_secs, 0, thread_number * sizeof(unsigned long));
263e529f 250
6043c579 251 io_bytes[0] = io_bytes[1] = 0;
adb02ba8 252 io_iops[0] = io_iops[1] = 0;
ac71feb1 253 nr_pending = nr_running = t_rate = m_rate = t_iops = m_iops = 0;
b29ee5b3 254 nr_ramp = 0;
bb3884d8 255 bw_avg_time = ULONG_MAX;
e6e41602 256 files_open = 0;
34572e28 257 for_each_td(td, i) {
2dc1bbeb
JA
258 if (td->o.bw_avg_time < bw_avg_time)
259 bw_avg_time = td->o.bw_avg_time;
46fda8d0 260 if (td->runstate == TD_RUNNING || td->runstate == TD_VERIFYING
b0f65863
JA
261 || td->runstate == TD_FSYNCING
262 || td->runstate == TD_PRE_READING) {
263e529f 263 nr_running++;
581e7141
JA
264 t_rate += td->o.rate[0] + td->o.rate[1];
265 m_rate += td->o.ratemin[0] + td->o.ratemin[1];
266 t_iops += td->o.rate_iops[0] + td->o.rate_iops[1];
267 m_iops += td->o.rate_iops_min[0] + td->o.rate_iops_min[1];
e6e41602 268 files_open += td->nr_open_files;
b29ee5b3
JA
269 } else if (td->runstate == TD_RAMP) {
270 nr_running++;
271 nr_ramp++;
263e529f
JA
272 } else if (td->runstate < TD_RUNNING)
273 nr_pending++;
274
275 if (elapsed >= 3)
b29ee5b3 276 eta_secs[i] = thread_eta(td);
263e529f
JA
277 else
278 eta_secs[i] = INT_MAX;
279
280 check_str_update(td);
b29ee5b3
JA
281
282 if (td->runstate > TD_RAMP) {
283 io_bytes[0] += td->io_bytes[0];
284 io_bytes[1] += td->io_bytes[1];
adb02ba8
JA
285 io_iops[0] += td->io_blocks[0];
286 io_iops[1] += td->io_blocks[1];
b29ee5b3 287 }
263e529f
JA
288 }
289
290 if (exitall_on_terminate)
291 eta_sec = INT_MAX;
292 else
293 eta_sec = 0;
294
34572e28 295 for_each_td(td, i) {
d6978a32
JA
296 if (!i2p && is_power_of_2(td->o.kb_base))
297 i2p = 1;
9c5a3854
SSY
298 if (exitall_on_terminate) {
299 if (eta_secs[i] < eta_sec)
300 eta_sec = eta_secs[i];
301 } else {
302 if (eta_secs[i] > eta_sec)
303 eta_sec = eta_secs[i];
304 }
263e529f
JA
305 }
306
eecf272f
JA
307 free(eta_secs);
308
263e529f
JA
309 if (eta_sec != INT_MAX && elapsed) {
310 perc = (double) elapsed / (double) (elapsed + eta_sec);
311 eta_to_str(eta_str, eta_sec);
312 }
313
46fda8d0
JA
314 fio_gettime(&now, NULL);
315 rate_time = mtime_since(&rate_prev_time, &now);
316
b29ee5b3 317 if (write_bw_log && rate_time > bw_avg_time && !in_ramp_time(td)) {
46fda8d0
JA
318 calc_rate(rate_time, io_bytes, rate_io_bytes, rate);
319 memcpy(&rate_prev_time, &now, sizeof(now));
306ddc97
JA
320 add_agg_sample(rate[DDIR_READ], DDIR_READ, 0);
321 add_agg_sample(rate[DDIR_WRITE], DDIR_WRITE, 0);
6043c579
JA
322 }
323
46fda8d0
JA
324 disp_time = mtime_since(&disp_prev_time, &now);
325 if (disp_time < 1000)
326 return;
327
328 calc_rate(disp_time, io_bytes, disp_io_bytes, rate);
adb02ba8
JA
329 calc_iops(disp_time, io_iops, disp_io_iops, iops);
330
46fda8d0
JA
331 memcpy(&disp_prev_time, &now, sizeof(now));
332
263e529f
JA
333 if (!nr_running && !nr_pending)
334 return;
335
e6e41602 336 printf("Jobs: %d (f=%d)", nr_running, files_open);
581e7141
JA
337 if (m_rate || t_rate) {
338 char *tr, *mr;
339
d6978a32
JA
340 mr = num2str(m_rate, 4, 0, i2p);
341 tr = num2str(t_rate, 4, 0, i2p);
b22989b9 342 printf(", CR=%s/%s KB/s", tr, mr);
581e7141
JA
343 free(tr);
344 free(mr);
345 } else if (m_iops || t_iops)
ac71feb1 346 printf(", CR=%d/%d IOPS", t_iops, m_iops);
263e529f 347 if (eta_sec != INT_MAX && nr_running) {
0721d11e 348 char perc_str[32];
adb02ba8 349 char *iops_str[2];
d1bd7213 350 char *rate_str[2];
adb02ba8 351 int l;
5ec10eaa 352
b29ee5b3 353 if ((!eta_sec && !eta_good) || nr_ramp == nr_running)
cac58fd5
JA
354 strcpy(perc_str, "-.-% done");
355 else {
356 eta_good = 1;
357 perc *= 100.0;
0721d11e 358 sprintf(perc_str, "%3.1f%% done", perc);
cac58fd5 359 }
0721d11e 360
d6978a32
JA
361 rate_str[0] = num2str(rate[0], 5, 10, i2p);
362 rate_str[1] = num2str(rate[1], 5, 10, i2p);
d1bd7213 363
adb02ba8
JA
364 iops_str[0] = num2str(iops[0], 4, 1, 0);
365 iops_str[1] = num2str(iops[1], 4, 1, 0);
366
d1bd7213
JA
367 l = printf(": [%s] [%s] [%s/%s /s] [%s/%s iops] [eta %s]",
368 run_str, perc_str, rate_str[0], rate_str[1],
adb02ba8
JA
369 iops_str[0], iops_str[1], eta_str);
370 if (l >= 0 && l < linelen_last)
371 printf("%*s", linelen_last - l, "");
372 linelen_last = l;
d1bd7213
JA
373
374 free(rate_str[0]);
375 free(rate_str[1]);
adb02ba8
JA
376 free(iops_str[0]);
377 free(iops_str[1]);
263e529f
JA
378 }
379 printf("\r");
380 fflush(stdout);
263e529f
JA
381}
382
383void print_status_init(int thread_number)
384{
385 run_str[thread_number] = 'P';
386}