btt/output.c

   1 /*
   2  * blktrace output analysis: generate a timeline & gather statistics
   3  *
   4  * Copyright (C) 2006 Alan D. Brunelle <Alan.Brunelle@hp.com>
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21 #include <stdio.h>
  22 #include "globals.h"
  23
  24 typedef struct avg_info *ai_dip_t;
  25 ai_dip_t dip_q2q_avg(struct d_info *dip) { return &dip->avgs.q2q; }
  26 ai_dip_t dip_q2c_avg(struct d_info *dip) { return &dip->avgs.q2c; }
  27 ai_dip_t dip_q2a_avg(struct d_info *dip) { return &dip->avgs.q2a; }
  28 ai_dip_t dip_q2i_avg(struct d_info *dip) { return &dip->avgs.q2i; }
  29 ai_dip_t dip_i2d_avg(struct d_info *dip) { return &dip->avgs.i2d; }
  30 ai_dip_t dip_d2c_avg(struct d_info *dip) { return &dip->avgs.d2c; }
  31
  32 typedef struct avg_info *ai_pip_t;
  33 ai_pip_t pip_q2q_avg(struct p_info *pip) { return &pip->avgs.q2q; }
  34 ai_pip_t pip_q2c_avg(struct p_info *pip) { return &pip->avgs.q2c; }
  35 ai_pip_t pip_q2a_avg(struct p_info *pip) { return &pip->avgs.q2a; }
  36 ai_pip_t pip_q2i_avg(struct p_info *pip) { return &pip->avgs.q2i; }
  37 ai_pip_t pip_i2d_avg(struct p_info *pip) { return &pip->avgs.i2d; }
  38 ai_pip_t pip_d2c_avg(struct p_info *pip) { return &pip->avgs.d2c; }
  39
  40 void output_section_hdr(FILE *ofp, char *hdr)
  41 {
  42         fprintf(ofp, "==================== ");
  43         fprintf(ofp, hdr);
  44         fprintf(ofp, " ====================\n\n");
  45 }
  46
  47 void output_hdr(FILE *ofp, char *hdr)
  48 {
  49         fprintf(ofp, "%15s %13s %13s %13s %11s\n",
  50                 hdr, "MIN", "AVG", "MAX", "N" );
  51         fprintf(ofp, "--------------- ------------- ------------- ------------- -----------\n");
  52 }
  53
  54 void __output_avg(FILE *ofp, char *hdr, struct avg_info *ap)
  55 {
  56         if (ap->n > 0) {
  57                 ap->avg = BIT_TIME(ap->total) / (double)ap->n;
  58                 fprintf(ofp, "%-15s %13.9f %13.9f %13.9f %11d\n", hdr,
  59                         BIT_TIME(ap->min), ap->avg, BIT_TIME(ap->max), ap->n);
  60         }
  61 }
  62
  63 void output_hdr2(FILE *ofp, char*hdr)
  64 {
  65         fprintf(ofp, "%15s %13s %13s %13s %13s %13s %13s\n", hdr, "Q2Q", "Q2A", "Q2I", "I2D", "D2C", "Q2C");
  66         fprintf(ofp, "--------------- ------------- ------------- ------------- ------------- ------------- -------------\n");
  67 }
  68
  69 static inline char *avg2string(struct avg_info *ap, char *string)
  70 {
  71         if (ap->n > 0)
  72                 sprintf(string, "%13.9f", ap->avg);
  73         else
  74                 sprintf(string, " ");
  75         return string;
  76 }
  77
  78 void __output_avg2(FILE *ofp, char *hdr, struct avgs_info *ap)
  79 {
  80         char c1[16], c2[16], c3[16], c4[16], c5[16], c6[16];
  81
  82         if (ap->q2q.n > 0 || ap->q2a.n > 0 || ap->q2i.n > 0 ||
  83                         ap->i2d.n > 0 || ap->d2c.n > 0 || ap->q2c.n > 0) {
  84                 fprintf(ofp, "%-15s %13s %13s %13s %13s %13s %13s\n", hdr,
  85                         avg2string(&ap->q2q,c1), avg2string(&ap->q2a,c2),
  86                         avg2string(&ap->q2i,c3), avg2string(&ap->i2d,c4),
  87                         avg2string(&ap->d2c,c5), avg2string(&ap->q2c,c6));
  88         }
  89 }
  90
  91 void __pip_output_avg2(struct p_info *pip, void *arg)
  92 {
  93         __output_avg2((FILE *)arg, pip->name, &pip->avgs);
  94 }
  95
  96 void __dip_output_avg2(struct d_info *dip, void *arg)
  97 {
  98         char dev_info[15];
  99         __output_avg2((FILE *)arg, make_dev_hdr(dev_info, 15, dip), &dip->avgs);
 100 }
 101
 102 char *make_dev_hdr(char *pad, size_t len, struct d_info *dip)
 103 {
 104         if (dip->map == NULL)
 105                 snprintf(pad, len, "(%3d,%3d)",
 106                          MAJOR(dip->device), MINOR(dip->device));
 107         else
 108                 snprintf(pad, len, "%s", dip->map->device);
 109
 110         return pad;
 111 }
 112
 113 struct __oda {
 114         FILE *ofp;
 115         ai_dip_t (*func)(struct d_info *);
 116 };
 117 void __output_dip_avg(struct d_info *dip, void *arg)
 118 {
 119         struct __oda *odap = arg;
 120         ai_dip_t ap = odap->func(dip);
 121         if (ap->n > 0) {
 122                 char dev_info[15];
 123                 ap->avg = BIT_TIME(ap->total) / (double)ap->n;
 124                 __output_avg(odap->ofp, make_dev_hdr(dev_info, 15, dip), ap);
 125         }
 126 }
 127
 128 void output_dip_avg(FILE *ofp, char *hdr, ai_dip_t (*func)(struct d_info *))
 129 {
 130         struct __oda oda = { .ofp = ofp, .func = func};
 131         output_hdr(ofp, hdr);
 132         dip_foreach_out(__output_dip_avg, &oda);
 133         fprintf(ofp, "\n");
 134 }
 135
 136 int n_merges = 0;
 137 struct {
 138         unsigned long long nq, nd, blkmin, blkmax, total;
 139 } merge_data;
 140 void __output_dip_merge_ratio(struct d_info *dip, void *arg)
 141 {
 142         double blks_avg;
 143         char scratch[15];
 144         double ratio, q2c_n = dip->avgs.q2c.n, d2c_n = dip->n_ds;
 145
 146         if (q2c_n > 0.0 && d2c_n > 0.0) {
 147                 ratio = q2c_n / d2c_n;
 148                 blks_avg = (double)dip->avgs.blks.total / d2c_n;
 149                 fprintf((FILE *)arg,
 150                         "%10s | %8llu %8llu %7.1lf | %8llu %8llu %8llu %8llu\n",
 151                         make_dev_hdr(scratch, 15, dip),
 152                         (unsigned long long)dip->avgs.q2c.n,
 153                         (unsigned long long)dip->n_ds,
 154                         ratio,
 155                         (unsigned long long)dip->avgs.blks.min,
 156                         (unsigned long long)blks_avg,
 157                         (unsigned long long)dip->avgs.blks.max,
 158                         (unsigned long long)dip->avgs.blks.total);
 159
 160                 if (n_merges++ == 0) {
 161                         merge_data.blkmin = dip->avgs.blks.min;
 162                         merge_data.blkmax = dip->avgs.blks.max;
 163                 }
 164
 165                 merge_data.nq += dip->avgs.q2c.n;
 166                 merge_data.nd += dip->n_ds;
 167                 merge_data.total += dip->avgs.blks.total;
 168                 if (dip->avgs.blks.min < merge_data.blkmin)
 169                         merge_data.blkmin = dip->avgs.blks.min;
 170                 if (dip->avgs.blks.max > merge_data.blkmax)
 171                         merge_data.blkmax = dip->avgs.blks.max;
 172         }
 173 }
 174
 175 void output_dip_merge_ratio(FILE *ofp)
 176 {
 177         fprintf(ofp, "%10s | %8s %8s %7s | %8s %8s %8s %8s\n", "DEV", "#Q", "#D", "Ratio", "BLKmin", "BLKavg", "BLKmax", "Total");
 178         fprintf(ofp, "---------- | -------- -------- ------- | -------- -------- -------- --------\n");
 179         dip_foreach_out(__output_dip_merge_ratio, ofp);
 180         if (n_merges > 1) {
 181                 fprintf(ofp, "---------- | -------- -------- ------- | -------- -------- -------- --------\n");
 182                 fprintf(ofp, "%10s | %8s %8s %7s | %8s %8s %8s %8s\n", "DEV", "#Q", "#D", "Ratio", "BLKmin", "BLKavg", "BLKmax", "Total");
 183                 fprintf((FILE *)ofp,
 184                         "%10s | %8llu %8llu %7.1lf | %8llu %8llu %8llu %8llu\n",
 185                         "TOTAL", merge_data.nq, merge_data.nd,
 186                         (float)merge_data.nq / (float)merge_data.nd,
 187                         merge_data.blkmin,
 188                         merge_data.total / merge_data.nd,
 189                         merge_data.blkmax, merge_data.total);
 190         }
 191         fprintf(ofp, "\n");
 192 }
 193
 194 #define AVG(a,b) (100.0 * ((double)(a) / (double)(b)))
 195 #define CALC_AVG(ap) (ap)->avg = ((ap)->n == 0 ? 0.0 :                    \
 196                                                  (BIT_TIME((ap)->total) / \
 197                                                         (double)(ap)->n))
 198 char *q2i_v_q2C(struct d_info *dip, char *s)
 199 {
 200         double q2c;
 201
 202         if (dip->avgs.q2i.n == 0) return " ";
 203
 204         q2c = dip->avgs.q2i.avg + dip->avgs.i2d.avg + dip->avgs.d2c.avg;
 205         sprintf(s, "%5.1lf%%", AVG(dip->avgs.q2i.avg, q2c));
 206
 207         return s;
 208 }
 209
 210 char *i2d_v_q2C(struct d_info *dip, char *s)
 211 {
 212         double q2c;
 213
 214         if (dip->avgs.d2c.n == 0) return " ";
 215
 216         q2c = dip->avgs.q2i.avg + dip->avgs.i2d.avg + dip->avgs.d2c.avg;
 217         sprintf(s, "%5.1lf%%", AVG(dip->avgs.i2d.avg, q2c));
 218
 219         return s;
 220 }
 221
 222 char *d2c_v_q2C(struct d_info *dip, char *s)
 223 {
 224         double q2c;
 225
 226         if (dip->avgs.d2c.n == 0) return " ";
 227
 228         q2c = dip->avgs.q2i.avg + dip->avgs.i2d.avg + dip->avgs.d2c.avg;
 229         sprintf(s, "%5.1lf%%", AVG(dip->avgs.d2c.avg, q2c));
 230
 231         return s;
 232 }
 233
 234 void __output_dip_prep_ohead(struct d_info *dip, void *arg)
 235 {
 236         char dev_info[15];
 237         char s1[16], s2[16], s3[16];
 238
 239         if ((dip->avgs.q2i.n > 0 && dip->avgs.i2d.n > 0 &&
 240                                                 dip->avgs.d2c.n > 0)) {
 241                 CALC_AVG(&dip->avgs.q2i);
 242                 CALC_AVG(&dip->avgs.i2d);
 243                 CALC_AVG(&dip->avgs.d2c);
 244
 245                 fprintf((FILE *)arg, "%10s | %6s %6s %6s\n",
 246                         make_dev_hdr(dev_info, 15, dip),
 247                         q2i_v_q2C(dip, s1), i2d_v_q2C(dip, s2),
 248                         d2c_v_q2C(dip, s3));
 249         }
 250 }
 251
 252 void output_dip_prep_ohead(FILE *ofp)
 253 {
 254         fprintf(ofp, "%10s | %6s %6s %6s\n", "DEV", "Q2I", "I2D", "D2C");
 255         fprintf(ofp, "---------- | ------ ------ ------\n");
 256         dip_foreach_out(__output_dip_prep_ohead, ofp);
 257         fprintf(ofp, "\n");
 258 }
 259
 260 void __output_dip_seek_info(struct d_info *dip, void *arg)
 261 {
 262         double mean;
 263         int i, nmodes;
 264         long long nseeks;
 265         char dev_info[15];
 266         long long median;
 267         struct mode m;
 268         FILE *ofp = arg;
 269
 270         nseeks = seeki_nseeks(dip->seek_handle);
 271         if (nseeks > 0) {
 272                 mean = seeki_mean(dip->seek_handle);
 273                 median = seeki_median(dip->seek_handle);
 274                 nmodes = seeki_mode(dip->seek_handle, &m);
 275
 276                 fprintf(ofp, "%10s | %15lld %15.1lf %15lld | %lld(%d)",
 277                         make_dev_hdr(dev_info, 15, dip), nseeks, mean, median,
 278                         nmodes > 0 ? m.modes[0] : 0, m.most_seeks);
 279                 for (i = 1; i < nmodes; i++)
 280                         fprintf(ofp, " %lld", m.modes[i]);
 281                 fprintf(ofp, "\n");
 282         }
 283 }
 284
 285 void output_dip_seek_info(FILE *ofp)
 286 {
 287         fprintf(ofp, "%10s | %15s %15s %15s | %-15s\n", "DEV", "NSEEKS",
 288                         "MEAN", "MEDIAN", "MODE");
 289         fprintf(ofp, "---------- "
 290                         "| --------------- --------------- --------------- "
 291                         "| ---------------\n");
 292         dip_foreach_out(__output_dip_seek_info, ofp);
 293         fprintf(ofp, "\n");
 294 }
 295
 296 struct __opa {
 297         FILE *ofp;
 298         ai_pip_t (*func)(struct p_info *);
 299 };
 300
 301 void __output_pip_avg(struct p_info *pip, void *arg)
 302 {
 303         struct __opa *opap = arg;
 304         ai_pip_t ap = opap->func(pip);
 305
 306         if (ap->n > 0) {
 307                 char proc_name[15];
 308                 snprintf(proc_name, 15, pip->name);
 309
 310                 ap->avg = BIT_TIME(ap->total) / (double)ap->n;
 311                 __output_avg(opap->ofp, proc_name, ap);
 312         }
 313 }
 314
 315 void output_pip_avg(FILE *ofp, char *hdr, ai_pip_t (*func)(struct p_info *))
 316 {
 317         struct __opa opa = { .ofp = ofp, .func = func };
 318
 319         output_hdr(ofp, hdr);
 320         pip_foreach_out(__output_pip_avg, &opa);
 321         fprintf(ofp, "\n");
 322 }
 323
 324 void output_dip_avgs(FILE *ofp)
 325 {
 326         output_hdr2(ofp,"Dev");
 327         dip_foreach_out(__dip_output_avg2, ofp);
 328         fprintf(ofp, "\n");
 329 }
 330
 331 void output_pip_avgs(FILE *ofp)
 332 {
 333         output_hdr2(ofp,"Exe");
 334         pip_foreach_out(__pip_output_avg2, ofp);
 335         fprintf(ofp, "\n");
 336 }
 337
 338 int output_avgs(FILE *ofp)
 339 {
 340         if (exes == NULL || *exes != '\0') {
 341                 output_section_hdr(ofp, "Per Process");
 342                 output_pip_avg(ofp, "Q2Q", pip_q2q_avg);
 343                 output_pip_avg(ofp, "Q2A", pip_q2a_avg);
 344                 output_pip_avg(ofp, "Q2I", pip_q2i_avg);
 345                 output_pip_avg(ofp, "I2D", pip_i2d_avg);
 346                 output_pip_avg(ofp, "D2C", pip_d2c_avg);
 347                 output_pip_avg(ofp, "Q2C", pip_q2c_avg);
 348         }
 349
 350         output_section_hdr(ofp, "Per Device");
 351         output_dip_avg(ofp, "Q2Q", dip_q2q_avg);
 352         output_dip_avg(ofp, "Q2A", dip_q2a_avg);
 353         output_dip_avg(ofp, "Q2I", dip_q2i_avg);
 354         output_dip_avg(ofp, "I2D", dip_i2d_avg);
 355         output_dip_avg(ofp, "D2C", dip_d2c_avg);
 356         output_dip_avg(ofp, "Q2C", dip_q2c_avg);
 357
 358         output_section_hdr(ofp, "All Devices");
 359         output_hdr(ofp, "ALL");
 360         __output_avg(ofp, "Q2Q", &all_avgs.q2q);
 361         __output_avg(ofp, "Q2A", &all_avgs.q2a);
 362         __output_avg(ofp, "Q2I", &all_avgs.q2i);
 363         __output_avg(ofp, "I2D", &all_avgs.i2d);
 364         __output_avg(ofp, "D2C", &all_avgs.d2c);
 365         __output_avg(ofp, "Q2C", &all_avgs.q2c);
 366
 367         if (exes == NULL || *exes != '\0') {
 368                 output_section_hdr(ofp, "Per Process (avgs)");
 369                 output_pip_avgs(ofp);
 370         }
 371
 372         output_section_hdr(ofp, "Per Device (avgs)");
 373         output_dip_avgs(ofp);
 374
 375         output_section_hdr(ofp, "Device Merge Information");
 376         output_dip_merge_ratio(ofp);
 377
 378         output_section_hdr(ofp, "Device Overhead");
 379         output_dip_prep_ohead(ofp);
 380
 381         output_section_hdr(ofp, "Device Seek Information");
 382         output_dip_seek_info(ofp);
 383
 384         return 0;
 385 }
 386
 387 void __output_ranges(FILE *ofp, struct list_head *head_p, float base)
 388 {
 389         struct range_info *rip;
 390         struct list_head *p;
 391         float limit = base + 0.4;
 392
 393         __list_for_each(p, head_p) {
 394                 rip = list_entry(p, struct range_info, head);
 395                 fprintf(ofp, "%13.9lf %5.1f\n", BIT_TIME(rip->start), base);
 396                 fprintf(ofp, "%13.9lf %5.1f\n", BIT_TIME(rip->start), limit);
 397                 fprintf(ofp, "%13.9lf %5.1f\n", BIT_TIME(rip->end), limit);
 398                 fprintf(ofp, "%13.9lf %5.1f\n", BIT_TIME(rip->end), base);
 399         }
 400 }
 401
 402 int output_regions(FILE *ofp, char *header, struct region_info *reg,
 403                           float base)
 404 {
 405         if (reg->qr_cur != NULL)
 406                 list_add_tail(&reg->qr_cur->head, &reg->qranges);
 407         if (reg->cr_cur != NULL)
 408                 list_add_tail(&reg->cr_cur->head, &reg->cranges);
 409
 410         if (list_len(&reg->qranges) == 0 && list_len(&reg->cranges) == 0)
 411                 return 0;
 412
 413         fprintf(ofp, "# %16s : q activity\n", header);
 414         __output_ranges(ofp, &reg->qranges, base);
 415         fprintf(ofp, "\n");
 416
 417         fprintf(ofp, "# %16s : c activity\n", header);
 418         __output_ranges(ofp, &reg->cranges, base + 0.5);
 419         fprintf(ofp, "\n");
 420
 421         return 1;
 422 }
 423
 424 struct __od {
 425         FILE *ofp;
 426         float base;
 427 };
 428 void __output_dev(struct d_info *dip, void *arg)
 429 {
 430         char header[128];
 431         struct __od *odp = arg;
 432
 433         sprintf(header, "%d,%d", MAJOR(dip->device), MINOR(dip->device));
 434         if (output_regions(odp->ofp, header, &dip->regions, odp->base))
 435                 odp->base += 1.0;
 436 }
 437
 438 float output_devs(FILE *ofp, float base)
 439 {
 440         struct __od od = { .ofp = ofp, .base = base };
 441
 442         fprintf(ofp, "# Per device\n" );
 443         dip_foreach_out(__output_dev, &od);
 444         return od.base;
 445 }
 446
 447 static inline int exe_match(char *exe, char *name)
 448 {
 449         return (exe == NULL) || (strstr(name, exe) != NULL);
 450 }
 451
 452 struct __op {
 453         FILE *ofp;
 454         float base;
 455 };
 456 void __output_procs(struct p_info *pip, void *arg)
 457 {
 458         struct __op *opp = arg;
 459         output_regions(opp->ofp, pip->name, &pip->regions, opp->base);
 460         opp->base += 1.0;
 461 }
 462
 463 float output_procs(FILE *ofp, float base)
 464 {
 465         struct __op op = { .ofp = ofp, .base = base };
 466
 467         fprintf(ofp, "# Per process\n" );
 468         pip_foreach_out(__output_procs, &op);
 469         return op.base;
 470 }
 471
 472 int output_ranges(FILE *ofp)
 473 {
 474         float base = 0.0;
 475
 476         fprintf(ofp, "# %s\n", "Total System");
 477         if (output_regions(ofp, "Total System", &all_regions, base))
 478                 base += 1.0;
 479
 480         if (n_devs > 1)
 481                 base = output_devs(ofp, base);
 482
 483         base = output_procs(ofp, base);
 484
 485         return 0;
 486 }