stat.c

   1 #include <stdio.h>
   2 #include <string.h>
   3 #include <sys/time.h>
   4 #include <sys/types.h>
   5 #include <sys/stat.h>
   6 #include <dirent.h>
   7 #include <libgen.h>
   8 #include <math.h>
   9
  10 #include "fio.h"
  11
  12 /*
  13  * Cheesy number->string conversion, complete with carry rounding error.
  14  */
  15 static char *num2str(unsigned long num, int maxlen, int base, int pow2)
  16 {
  17         char postfix[] = { ' ', 'K', 'M', 'G', 'P', 'E' };
  18         unsigned int thousand;
  19         char *buf;
  20         int i;
  21
  22         if (pow2)
  23                 thousand = 1024;
  24         else
  25                 thousand = 1000;
  26
  27         buf = malloc(128);
  28
  29         for (i = 0; base > 1; i++)
  30                 base /= thousand;
  31
  32         do {
  33                 int len, carry = 0;
  34
  35                 len = sprintf(buf, "%'lu", num);
  36                 if (len <= maxlen) {
  37                         if (i >= 1) {
  38                                 buf[len] = postfix[i];
  39                                 buf[len + 1] = '\0';
  40                         }
  41                         return buf;
  42                 }
  43
  44                 if ((num % thousand) >= (thousand / 2))
  45                         carry = 1;
  46
  47                 num /= thousand;
  48                 num += carry;
  49                 i++;
  50         } while (i <= 5);
  51
  52         return buf;
  53 }
  54
  55 void update_rusage_stat(struct thread_data *td)
  56 {
  57         struct thread_stat *ts = &td->ts;
  58
  59         getrusage(RUSAGE_SELF, &ts->ru_end);
  60
  61         ts->usr_time += mtime_since(&ts->ru_start.ru_utime, &ts->ru_end.ru_utime);
  62         ts->sys_time += mtime_since(&ts->ru_start.ru_stime, &ts->ru_end.ru_stime);
  63         ts->ctx += ts->ru_end.ru_nvcsw + ts->ru_end.ru_nivcsw - (ts->ru_start.ru_nvcsw + ts->ru_start.ru_nivcsw);
  64         ts->minf += ts->ru_end.ru_minflt - ts->ru_start.ru_minflt;
  65         ts->majf += ts->ru_end.ru_majflt - ts->ru_start.ru_majflt;
  66
  67         memcpy(&ts->ru_start, &ts->ru_end, sizeof(ts->ru_end));
  68 }
  69
  70 static int calc_lat(struct io_stat *is, unsigned long *min, unsigned long *max,
  71                     double *mean, double *dev)
  72 {
  73         double n = is->samples;
  74
  75         if (is->samples == 0)
  76                 return 0;
  77
  78         *min = is->min_val;
  79         *max = is->max_val;
  80
  81         n = (double) is->samples;
  82         *mean = is->mean;
  83
  84         if (n > 1.0)
  85                 *dev = sqrt(is->S / (n - 1.0));
  86         else
  87                 *dev = 0;
  88
  89         return 1;
  90 }
  91
  92 static void show_group_stats(struct group_run_stats *rs, int id)
  93 {
  94         char *p1, *p2, *p3, *p4;
  95         const char *ddir_str[] = { "   READ", "  WRITE" };
  96         int i;
  97
  98         log_info("\nRun status group %d (all jobs):\n", id);
  99
 100         for (i = 0; i <= DDIR_WRITE; i++) {
 101                 if (!rs->max_run[i])
 102                         continue;
 103
 104                 p1 = num2str(rs->io_kb[i], 6, 1000, 1);
 105                 p2 = num2str(rs->agg[i], 6, 1000, 1);
 106                 p3 = num2str(rs->min_bw[i], 6, 1000, 1);
 107                 p4 = num2str(rs->max_bw[i], 6, 1000, 1);
 108
 109                 log_info("%s: io=%siB, aggrb=%siB/s, minb=%siB/s, maxb=%siB/s, mint=%llumsec, maxt=%llumsec\n", ddir_str[i], p1, p2, p3, p4, rs->min_run[i], rs->max_run[i]);
 110
 111                 free(p1);
 112                 free(p2);
 113                 free(p3);
 114                 free(p4);
 115         }
 116 }
 117
 118 #define ts_total_io_u(ts)       \
 119         ((ts)->total_io_u[0] + (ts)->total_io_u[1])
 120
 121 static void stat_calc_dist(struct thread_stat *ts, double *io_u_dist)
 122 {
 123         int i;
 124
 125         /*
 126          * Do depth distribution calculations
 127          */
 128         for (i = 0; i < FIO_IO_U_MAP_NR; i++) {
 129                 io_u_dist[i] = (double) ts->io_u_map[i] / (double) ts_total_io_u(ts);
 130                 io_u_dist[i] *= 100.0;
 131                 if (io_u_dist[i] < 0.1 && ts->io_u_map[i])
 132                         io_u_dist[i] = 0.1;
 133         }
 134 }
 135
 136 static void stat_calc_lat(struct thread_stat *ts, double *dst,
 137                           unsigned int *src, int nr)
 138 {
 139         int i;
 140
 141         /*
 142          * Do latency distribution calculations
 143          */
 144         for (i = 0; i < nr; i++) {
 145                 dst[i] = (double) src[i] / (double) ts_total_io_u(ts);
 146                 dst[i] *= 100.0;
 147                 if (dst[i] < 0.01 && src[i])
 148                         dst[i] = 0.01;
 149         }
 150 }
 151
 152 static void stat_calc_lat_u(struct thread_stat *ts, double *io_u_lat)
 153 {
 154         stat_calc_lat(ts, io_u_lat, ts->io_u_lat_u, FIO_IO_U_LAT_U_NR);
 155 }
 156
 157 static void stat_calc_lat_m(struct thread_stat *ts, double *io_u_lat)
 158 {
 159         stat_calc_lat(ts, io_u_lat, ts->io_u_lat_m, FIO_IO_U_LAT_M_NR);
 160 }
 161
 162 static int usec_to_msec(unsigned long *min, unsigned long *max, double *mean,
 163                         double *dev)
 164 {
 165         if (*min > 1000 && *max > 1000 && *mean > 1000.0 && *dev > 1000.0) {
 166                 *min /= 1000;
 167                 *max /= 1000;
 168                 *mean /= 1000.0;
 169                 *dev /= 1000.0;
 170                 return 0;
 171         }
 172
 173         return 1;
 174 }
 175
 176 static void show_ddir_status(struct group_run_stats *rs, struct thread_stat *ts,
 177                              int ddir)
 178 {
 179         const char *ddir_str[] = { "read ", "write" };
 180         unsigned long min, max;
 181         unsigned long long bw, iops;
 182         double mean, dev;
 183         char *io_p, *bw_p, *iops_p;
 184
 185         if (!ts->runtime[ddir])
 186                 return;
 187
 188         bw = ts->io_bytes[ddir] / ts->runtime[ddir];
 189         iops = (1000 * ts->total_io_u[ddir]) / ts->runtime[ddir];
 190         io_p = num2str(ts->io_bytes[ddir] >> 10, 6, 1000, 1);
 191         bw_p = num2str(bw, 6, 1000, 1);
 192         iops_p = num2str(iops, 6, 1, 0);
 193
 194         log_info("  %s: io=%siB, bw=%siB/s, iops=%s, runt=%6lumsec\n", ddir_str[ddir], io_p, bw_p, iops_p, ts->runtime[ddir]);
 195
 196         free(io_p);
 197         free(bw_p);
 198         free(iops_p);
 199
 200         if (calc_lat(&ts->slat_stat[ddir], &min, &max, &mean, &dev)) {
 201                 const char *base = "(usec)";
 202                 char *minp, *maxp;
 203
 204                 if (!usec_to_msec(&min, &max, &mean, &dev))
 205                         base = "(msec)";
 206
 207                 minp = num2str(min, 6, 1, 0);
 208                 maxp = num2str(max, 6, 1, 0);
 209
 210                 log_info("    slat %s: min=%s, max=%s, avg=%5.02f, stdev=%5.02f\n", base, minp, maxp, mean, dev);
 211
 212                 free(minp);
 213                 free(maxp);
 214         }
 215         if (calc_lat(&ts->clat_stat[ddir], &min, &max, &mean, &dev)) {
 216                 const char *base = "(usec)";
 217                 char *minp, *maxp;
 218
 219                 if (!usec_to_msec(&min, &max, &mean, &dev))
 220                         base = "(msec)";
 221
 222                 minp = num2str(min, 6, 1, 0);
 223                 maxp = num2str(max, 6, 1, 0);
 224
 225                 log_info("    clat %s: min=%s, max=%s, avg=%5.02f, stdev=%5.02f\n", base, minp, maxp, mean, dev);
 226
 227                 free(minp);
 228                 free(maxp);
 229         }
 230         if (calc_lat(&ts->bw_stat[ddir], &min, &max, &mean, &dev)) {
 231                 double p_of_agg;
 232
 233                 p_of_agg = mean * 100 / (double) rs->agg[ddir];
 234                 log_info("    bw (KiB/s) : min=%5lu, max=%5lu, per=%3.2f%%, avg=%5.02f, stdev=%5.02f\n", min, max, p_of_agg, mean, dev);
 235         }
 236 }
 237
 238 static void show_lat(double *io_u_lat, int nr, const char **ranges,
 239                      const char *msg)
 240 {
 241         int new_line = 1, i, line = 0;
 242
 243         for (i = 0; i < nr; i++) {
 244                 if (io_u_lat[i] <= 0.0)
 245                         continue;
 246                 if (new_line) {
 247                         if (line)
 248                                 log_info("\n");
 249                         log_info("     lat (%s): ", msg);
 250                         new_line = 0;
 251                         line = 0;
 252                 }
 253                 if (line)
 254                         log_info(", ");
 255                 log_info("%s%3.2f%%", ranges[i], io_u_lat[i]);
 256                 line++;
 257                 if (line == 5)
 258                         new_line = 1;
 259         }
 260 }
 261
 262 static void show_lat_u(double *io_u_lat_u)
 263 {
 264         const char *ranges[] = { "2=", "4=", "10=", "20=", "50=", "100=",
 265                                  "250=", "500=", "750=", "1000=", };
 266
 267         show_lat(io_u_lat_u, FIO_IO_U_LAT_U_NR, ranges, "usec");
 268 }
 269
 270 static void show_lat_m(double *io_u_lat_m)
 271 {
 272         const char *ranges[] = { "2=", "4=", "10=", "20=", "50=", "100=",
 273                                  "250=", "500=", "750=", "1000=", "2000=",
 274                                  ">=2000=", };
 275
 276         show_lat(io_u_lat_m, FIO_IO_U_LAT_M_NR, ranges, "msec");
 277 }
 278
 279 static void show_latencies(double *io_u_lat_u, double *io_u_lat_m)
 280 {
 281         show_lat_u(io_u_lat_u);
 282         log_info("\n");
 283         show_lat_m(io_u_lat_m);
 284         log_info("\n");
 285 }
 286
 287 static void show_thread_status(struct thread_stat *ts,
 288                                struct group_run_stats *rs)
 289 {
 290         double usr_cpu, sys_cpu;
 291         unsigned long runtime;
 292         double io_u_dist[FIO_IO_U_MAP_NR];
 293         double io_u_lat_u[FIO_IO_U_LAT_U_NR];
 294         double io_u_lat_m[FIO_IO_U_LAT_M_NR];
 295
 296         if (!(ts->io_bytes[0] + ts->io_bytes[1]))
 297                 return;
 298
 299         if (!ts->error)
 300                 log_info("%s: (groupid=%d, jobs=%d): err=%2d: pid=%d\n", ts->name, ts->groupid, ts->members, ts->error, ts->pid);
 301         else
 302                 log_info("%s: (groupid=%d, jobs=%d): err=%2d (%s): pid=%d\n", ts->name, ts->groupid, ts->members, ts->error, ts->verror, ts->pid);
 303
 304         if (ts->description)
 305                 log_info("  Description  : [%s]\n", ts->description);
 306
 307         if (ts->io_bytes[DDIR_READ])
 308                 show_ddir_status(rs, ts, DDIR_READ);
 309         if (ts->io_bytes[DDIR_WRITE])
 310                 show_ddir_status(rs, ts, DDIR_WRITE);
 311
 312         runtime = ts->total_run_time;
 313         if (runtime) {
 314                 double runt = (double) runtime;
 315
 316                 usr_cpu = (double) ts->usr_time * 100 / runt;
 317                 sys_cpu = (double) ts->sys_time * 100 / runt;
 318         } else {
 319                 usr_cpu = 0;
 320                 sys_cpu = 0;
 321         }
 322
 323         log_info("  cpu          : usr=%3.2f%%, sys=%3.2f%%, ctx=%lu, majf=%lu, minf=%lu\n", usr_cpu, sys_cpu, ts->ctx, ts->majf, ts->minf);
 324
 325         stat_calc_dist(ts, io_u_dist);
 326         stat_calc_lat_u(ts, io_u_lat_u);
 327         stat_calc_lat_m(ts, io_u_lat_m);
 328
 329         log_info("  IO depths    : 1=%3.1f%%, 2=%3.1f%%, 4=%3.1f%%, 8=%3.1f%%, 16=%3.1f%%, 32=%3.1f%%, >=64=%3.1f%%\n", io_u_dist[0], io_u_dist[1], io_u_dist[2], io_u_dist[3], io_u_dist[4], io_u_dist[5], io_u_dist[6]);
 330         log_info("     issued r/w: total=%lu/%lu, short=%lu/%lu\n", ts->total_io_u[0], ts->total_io_u[1], ts->short_io_u[0], ts->short_io_u[1]);
 331
 332         show_latencies(io_u_lat_u, io_u_lat_m);
 333 }
 334
 335 static void show_ddir_status_terse(struct thread_stat *ts,
 336                                    struct group_run_stats *rs, int ddir)
 337 {
 338         unsigned long min, max;
 339         unsigned long long bw;
 340         double mean, dev;
 341
 342         bw = 0;
 343         if (ts->runtime[ddir])
 344                 bw = ts->io_bytes[ddir] / ts->runtime[ddir];
 345
 346         log_info(";%llu;%llu;%lu", ts->io_bytes[ddir] >> 10, bw, ts->runtime[ddir]);
 347
 348         if (calc_lat(&ts->slat_stat[ddir], &min, &max, &mean, &dev))
 349                 log_info(";%lu;%lu;%f;%f", min, max, mean, dev);
 350         else
 351                 log_info(";%lu;%lu;%f;%f", 0UL, 0UL, 0.0, 0.0);
 352
 353         if (calc_lat(&ts->clat_stat[ddir], &min, &max, &mean, &dev))
 354                 log_info(";%lu;%lu;%f;%f", min, max, mean, dev);
 355         else
 356                 log_info(";%lu;%lu;%f;%f", 0UL, 0UL, 0.0, 0.0);
 357
 358         if (calc_lat(&ts->bw_stat[ddir], &min, &max, &mean, &dev)) {
 359                 double p_of_agg;
 360
 361                 p_of_agg = mean * 100 / (double) rs->agg[ddir];
 362                 log_info(";%lu;%lu;%f%%;%f;%f", min, max, p_of_agg, mean, dev);
 363         } else
 364                 log_info(";%lu;%lu;%f%%;%f;%f", 0UL, 0UL, 0.0, 0.0, 0.0);
 365 }
 366
 367
 368 static void show_thread_status_terse(struct thread_stat *ts,
 369                                      struct group_run_stats *rs)
 370 {
 371         double io_u_dist[FIO_IO_U_MAP_NR];
 372         double io_u_lat_u[FIO_IO_U_LAT_U_NR];
 373         double io_u_lat_m[FIO_IO_U_LAT_M_NR];
 374         double usr_cpu, sys_cpu;
 375         int i;
 376
 377         log_info("%s;%d;%d", ts->name, ts->groupid, ts->error);
 378
 379         show_ddir_status_terse(ts, rs, 0);
 380         show_ddir_status_terse(ts, rs, 1);
 381
 382         if (ts->total_run_time) {
 383                 double runt = (double) ts->total_run_time;
 384
 385                 usr_cpu = (double) ts->usr_time * 100 / runt;
 386                 sys_cpu = (double) ts->sys_time * 100 / runt;
 387         } else {
 388                 usr_cpu = 0;
 389                 sys_cpu = 0;
 390         }
 391
 392         log_info(";%f%%;%f%%;%lu;%lu;%lu", usr_cpu, sys_cpu, ts->ctx, ts->majf, ts->minf);
 393
 394         stat_calc_dist(ts, io_u_dist);
 395         stat_calc_lat_u(ts, io_u_lat_u);
 396         stat_calc_lat_m(ts, io_u_lat_m);
 397
 398         log_info(";%3.1f%%;%3.1f%%;%3.1f%%;%3.1f%%;%3.1f%%;%3.1f%%;%3.1f%%", io_u_dist[0], io_u_dist[1], io_u_dist[2], io_u_dist[3], io_u_dist[4], io_u_dist[5], io_u_dist[6]);
 399
 400         for (i = 0; i < FIO_IO_U_LAT_U_NR; i++)
 401                 log_info(";%3.2f%%", io_u_lat_u[i]);
 402         for (i = 0; i < FIO_IO_U_LAT_M_NR; i++)
 403                 log_info(";%3.2f%%", io_u_lat_m[i]);
 404         log_info("\n");
 405
 406         if (ts->description)
 407                 log_info(";%s", ts->description);
 408
 409         log_info("\n");
 410 }
 411
 412 static void sum_stat(struct io_stat *dst, struct io_stat *src, int nr)
 413 {
 414         double mean, S;
 415
 416         dst->min_val = min(dst->min_val, src->min_val);
 417         dst->max_val = max(dst->max_val, src->max_val);
 418         dst->samples += src->samples;
 419
 420         /*
 421          * Needs a new method for calculating stddev, we cannot just
 422          * average them we do below for nr > 1
 423          */
 424         if (nr == 1) {
 425                 mean = src->mean;
 426                 S = src->S;
 427         } else {
 428                 mean = ((src->mean * (double) (nr - 1)) + dst->mean) / ((double) nr);
 429                 S = ((src->S * (double) (nr - 1)) + dst->S) / ((double) nr);
 430         }
 431
 432         dst->mean = mean;
 433         dst->S = S;
 434 }
 435
 436 void show_run_stats(void)
 437 {
 438         struct group_run_stats *runstats, *rs;
 439         struct thread_data *td;
 440         struct thread_stat *threadstats, *ts;
 441         int i, j, k, l, nr_ts, last_ts, idx;
 442
 443         runstats = malloc(sizeof(struct group_run_stats) * (groupid + 1));
 444
 445         for (i = 0; i < groupid + 1; i++) {
 446                 rs = &runstats[i];
 447
 448                 memset(rs, 0, sizeof(*rs));
 449                 rs->min_bw[0] = rs->min_run[0] = ~0UL;
 450                 rs->min_bw[1] = rs->min_run[1] = ~0UL;
 451         }
 452
 453         /*
 454          * find out how many threads stats we need. if group reporting isn't
 455          * enabled, it's one-per-td.
 456          */
 457         nr_ts = 0;
 458         last_ts = -1;
 459         for_each_td(td, i) {
 460                 if (!td->o.group_reporting) {
 461                         nr_ts++;
 462                         continue;
 463                 }
 464                 if (last_ts == td->groupid)
 465                         continue;
 466
 467                 last_ts = td->groupid;
 468                 nr_ts++;
 469         }
 470
 471         threadstats = malloc(nr_ts * sizeof(struct thread_stat));
 472
 473         for (i = 0; i < nr_ts; i++) {
 474                 ts = &threadstats[i];
 475
 476                 memset(ts, 0, sizeof(*ts));
 477                 for (j = 0; j <= DDIR_WRITE; j++) {
 478                         ts->clat_stat[j].min_val = -1UL;
 479                         ts->slat_stat[j].min_val = -1UL;
 480                         ts->bw_stat[j].min_val = -1UL;
 481                 }
 482                 ts->groupid = -1;
 483         }
 484
 485         j = 0;
 486         last_ts = -1;
 487         idx = 0;
 488         for_each_td(td, i) {
 489                 if (idx && (!td->o.group_reporting ||
 490                     (td->o.group_reporting && last_ts != td->groupid))) {
 491                         idx = 0;
 492                         j++;
 493                 }
 494
 495                 last_ts = td->groupid;
 496
 497                 ts = &threadstats[j];
 498
 499                 idx++;
 500                 ts->members++;
 501
 502                 if (ts->groupid == -1) {
 503                         /*
 504                          * These are per-group shared already
 505                          */
 506                         ts->name = td->o.name;
 507                         ts->description = td->o.description;
 508                         ts->groupid = td->groupid;
 509
 510                         /*
 511                          * first pid in group, not very useful...
 512                          */
 513                         ts->pid = td->pid;
 514                 }
 515
 516                 if (td->error && !ts->error) {
 517                         ts->error = td->error;
 518                         ts->verror = td->verror;
 519                 }
 520
 521                 for (l = 0; l <= DDIR_WRITE; l++) {
 522                         sum_stat(&ts->clat_stat[l], &td->ts.clat_stat[l], idx);
 523                         sum_stat(&ts->slat_stat[l], &td->ts.slat_stat[l], idx);
 524                         sum_stat(&ts->bw_stat[l], &td->ts.bw_stat[l], idx);
 525
 526                         ts->stat_io_bytes[l] += td->ts.stat_io_bytes[l];
 527                         ts->io_bytes[l] += td->ts.io_bytes[l];
 528
 529                         if (ts->runtime[l] < td->ts.runtime[l])
 530                                 ts->runtime[l] = td->ts.runtime[l];
 531                 }
 532
 533                 ts->usr_time += td->ts.usr_time;
 534                 ts->sys_time += td->ts.sys_time;
 535                 ts->ctx += td->ts.ctx;
 536                 ts->majf += td->ts.majf;
 537                 ts->minf += td->ts.minf;
 538
 539                 for (k = 0; k < FIO_IO_U_MAP_NR; k++)
 540                         ts->io_u_map[k] += td->ts.io_u_map[k];
 541                 for (k = 0; k < FIO_IO_U_LAT_U_NR; k++)
 542                         ts->io_u_lat_u[k] += td->ts.io_u_lat_u[k];
 543                 for (k = 0; k < FIO_IO_U_LAT_M_NR; k++)
 544                         ts->io_u_lat_m[k] += td->ts.io_u_lat_m[k];
 545
 546
 547                 for (k = 0; k <= DDIR_WRITE; k++) {
 548                         ts->total_io_u[k] += td->ts.total_io_u[k];
 549                         ts->short_io_u[k] += td->ts.short_io_u[k];
 550                 }
 551
 552                 ts->total_run_time += td->ts.total_run_time;
 553         }
 554
 555         for (i = 0; i < nr_ts; i++) {
 556                 unsigned long long bw;
 557
 558                 ts = &threadstats[i];
 559                 rs = &runstats[ts->groupid];
 560
 561                 for (j = 0; j <= DDIR_WRITE; j++) {
 562                         if (!ts->runtime[j])
 563                                 continue;
 564                         if (ts->runtime[j] < rs->min_run[j] || !rs->min_run[j])
 565                                 rs->min_run[j] = ts->runtime[j];
 566                         if (ts->runtime[j] > rs->max_run[j])
 567                                 rs->max_run[j] = ts->runtime[j];
 568
 569                         bw = 0;
 570                         if (ts->runtime[j])
 571                                 bw = ts->io_bytes[j] / (unsigned long long) ts->runtime[j];
 572                         if (bw < rs->min_bw[j])
 573                                 rs->min_bw[j] = bw;
 574                         if (bw > rs->max_bw[j])
 575                                 rs->max_bw[j] = bw;
 576
 577                         rs->io_kb[j] += ts->io_bytes[j] >> 10;
 578                 }
 579         }
 580
 581         for (i = 0; i < groupid + 1; i++) {
 582                 rs = &runstats[i];
 583
 584                 if (rs->max_run[0])
 585                         rs->agg[0] = (rs->io_kb[0]*1024) / rs->max_run[0];
 586                 if (rs->max_run[1])
 587                         rs->agg[1] = (rs->io_kb[1]*1024) / rs->max_run[1];
 588         }
 589
 590         /*
 591          * don't overwrite last signal output
 592          */
 593         if (!terse_output)
 594                 printf("\n");
 595
 596         for (i = 0; i < nr_ts; i++) {
 597                 ts = &threadstats[i];
 598                 rs = &runstats[ts->groupid];
 599
 600                 if (terse_output)
 601                         show_thread_status_terse(ts, rs);
 602                 else
 603                         show_thread_status(ts, rs);
 604         }
 605
 606         if (!terse_output) {
 607                 for (i = 0; i < groupid + 1; i++)
 608                         show_group_stats(&runstats[i], i);
 609
 610                 show_disk_util();
 611         }
 612
 613         free(runstats);
 614         free(threadstats);
 615 }
 616
 617 static inline void add_stat_sample(struct io_stat *is, unsigned long data)
 618 {
 619         double val = data;
 620         double delta;
 621
 622         if (data > is->max_val)
 623                 is->max_val = data;
 624         if (data < is->min_val)
 625                 is->min_val = data;
 626
 627         delta = val - is->mean;
 628         if (delta) {
 629                 is->mean += delta / (is->samples + 1.0);
 630                 is->S += delta * (val - is->mean);
 631         }
 632
 633         is->samples++;
 634 }
 635
 636 static void __add_log_sample(struct io_log *iolog, unsigned long val,
 637                              enum fio_ddir ddir, unsigned long time)
 638 {
 639         if (iolog->nr_samples == iolog->max_samples) {
 640                 int new_size = sizeof(struct io_sample) * iolog->max_samples*2;
 641
 642                 iolog->log = realloc(iolog->log, new_size);
 643                 iolog->max_samples <<= 1;
 644         }
 645
 646         iolog->log[iolog->nr_samples].val = val;
 647         iolog->log[iolog->nr_samples].time = time;
 648         iolog->log[iolog->nr_samples].ddir = ddir;
 649         iolog->nr_samples++;
 650 }
 651
 652 static void add_log_sample(struct thread_data *td, struct io_log *iolog,
 653                            unsigned long val, enum fio_ddir ddir)
 654 {
 655         __add_log_sample(iolog, val, ddir, mtime_since_now(&td->epoch));
 656 }
 657
 658 void add_agg_sample(unsigned long val, enum fio_ddir ddir)
 659 {
 660         struct io_log *iolog = agg_io_log[ddir];
 661
 662         __add_log_sample(iolog, val, ddir, mtime_since_genesis());
 663 }
 664
 665 void add_clat_sample(struct thread_data *td, enum fio_ddir ddir,
 666                      unsigned long usec)
 667 {
 668         struct thread_stat *ts = &td->ts;
 669
 670         add_stat_sample(&ts->clat_stat[ddir], usec);
 671
 672         if (ts->clat_log)
 673                 add_log_sample(td, ts->clat_log, usec, ddir);
 674 }
 675
 676 void add_slat_sample(struct thread_data *td, enum fio_ddir ddir,
 677                      unsigned long usec)
 678 {
 679         struct thread_stat *ts = &td->ts;
 680
 681         add_stat_sample(&ts->slat_stat[ddir], usec);
 682
 683         if (ts->slat_log)
 684                 add_log_sample(td, ts->slat_log, usec, ddir);
 685 }
 686
 687 void add_bw_sample(struct thread_data *td, enum fio_ddir ddir,
 688                    struct timeval *t)
 689 {
 690         struct thread_stat *ts = &td->ts;
 691         unsigned long spent = mtime_since(&ts->stat_sample_time[ddir], t);
 692         unsigned long rate;
 693
 694         if (spent < td->o.bw_avg_time)
 695                 return;
 696
 697         rate = (td->this_io_bytes[ddir] - ts->stat_io_bytes[ddir]) / spent;
 698         add_stat_sample(&ts->bw_stat[ddir], rate);
 699
 700         if (ts->bw_log)
 701                 add_log_sample(td, ts->bw_log, rate, ddir);
 702
 703         fio_gettime(&ts->stat_sample_time[ddir], NULL);
 704         ts->stat_io_bytes[ddir] = td->this_io_bytes[ddir];
 705 }