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_dm_avg(struct d_info *dip) { return &dip->avgs.q2q_dm; }
  26 ai_dip_t dip_q2a_dm_avg(struct d_info *dip) { return &dip->avgs.q2a_dm; }
  27 ai_dip_t dip_q2c_dm_avg(struct d_info *dip) { return &dip->avgs.q2c_dm; }
  28
  29 ai_dip_t dip_q2q_avg(struct d_info *dip) { return &dip->avgs.q2q; }
  30 ai_dip_t dip_q2c_avg(struct d_info *dip) { return &dip->avgs.q2c; }
  31 ai_dip_t dip_q2a_avg(struct d_info *dip) { return &dip->avgs.q2a; }
  32 ai_dip_t dip_q2g_avg(struct d_info *dip) { return &dip->avgs.q2g; }
  33 ai_dip_t dip_g2i_avg(struct d_info *dip) { return &dip->avgs.g2i; }
  34 ai_dip_t dip_q2m_avg(struct d_info *dip) { return &dip->avgs.q2m; }
  35 ai_dip_t dip_i2d_avg(struct d_info *dip) { return &dip->avgs.i2d; }
  36 ai_dip_t dip_d2c_avg(struct d_info *dip) { return &dip->avgs.d2c; }
  37
  38 typedef struct avg_info *ai_pip_t;
  39 ai_pip_t pip_q2q_dm_avg(struct p_info *pip) { return &pip->avgs.q2q_dm; }
  40 ai_pip_t pip_q2a_dm_avg(struct p_info *pip) { return &pip->avgs.q2a_dm; }
  41 ai_pip_t pip_q2c_dm_avg(struct p_info *pip) { return &pip->avgs.q2c_dm; }
  42
  43 ai_pip_t pip_q2q_avg(struct p_info *pip) { return &pip->avgs.q2q; }
  44 ai_pip_t pip_q2c_avg(struct p_info *pip) { return &pip->avgs.q2c; }
  45 ai_pip_t pip_q2a_avg(struct p_info *pip) { return &pip->avgs.q2a; }
  46 ai_pip_t pip_q2g_avg(struct p_info *pip) { return &pip->avgs.q2g; }
  47 ai_pip_t pip_g2i_avg(struct p_info *pip) { return &pip->avgs.g2i; }
  48 ai_pip_t pip_q2m_avg(struct p_info *pip) { return &pip->avgs.q2m; }
  49 ai_pip_t pip_i2d_avg(struct p_info *pip) { return &pip->avgs.i2d; }
  50 ai_pip_t pip_d2c_avg(struct p_info *pip) { return &pip->avgs.d2c; }
  51
  52 void output_section_hdr(FILE *ofp, char *hdr)
  53 {
  54         fprintf(ofp, "==================== ");
  55         fprintf(ofp, hdr);
  56         fprintf(ofp, " ====================\n\n");
  57 }
  58
  59 void output_hdr(FILE *ofp, char *hdr)
  60 {
  61         fprintf(ofp, "%15s %13s %13s %13s %11s\n",
  62                 hdr, "MIN", "AVG", "MAX", "N" );
  63         fprintf(ofp, "--------------- ------------- ------------- ------------- -----------\n");
  64 }
  65
  66 void __output_avg(FILE *ofp, char *hdr, struct avg_info *ap)
  67 {
  68         if (ap->n > 0) {
  69                 ap->avg = BIT_TIME(ap->total) / (double)ap->n;
  70                 fprintf(ofp, "%-15s %13.9f %13.9f %13.9f %11d\n", hdr,
  71                         BIT_TIME(ap->min), ap->avg, BIT_TIME(ap->max), ap->n);
  72         }
  73 }
  74
  75 static inline char *avg2string(struct avg_info *ap, char *string)
  76 {
  77         if (ap->n > 0)
  78                 sprintf(string, "%13.9f", ap->avg);
  79         else
  80                 sprintf(string, " ");
  81         return string;
  82 }
  83
  84 char *make_dev_hdr(char *pad, size_t len, struct d_info *dip)
  85 {
  86         if (dip->map == NULL)
  87                 snprintf(pad, len, "(%3d,%3d)",
  88                          MAJOR(dip->device), MINOR(dip->device));
  89         else
  90                 snprintf(pad, len, "%s", dip->map->device);
  91
  92         return pad;
  93 }
  94
  95 struct __oda {
  96         FILE *ofp;
  97         ai_dip_t (*func)(struct d_info *);
  98 };
  99 void __output_dip_avg(struct d_info *dip, void *arg)
 100 {
 101         struct __oda *odap = arg;
 102         ai_dip_t ap = odap->func(dip);
 103         if (ap->n > 0) {
 104                 char dev_info[15];
 105                 ap->avg = BIT_TIME(ap->total) / (double)ap->n;
 106                 __output_avg(odap->ofp, make_dev_hdr(dev_info, 15, dip), ap);
 107         }
 108 }
 109
 110 void output_dip_avg(FILE *ofp, char *hdr, ai_dip_t (*func)(struct d_info *))
 111 {
 112         struct __oda oda = { .ofp = ofp, .func = func};
 113         output_hdr(ofp, hdr);
 114         dip_foreach_out(__output_dip_avg, &oda);
 115         fprintf(ofp, "\n");
 116 }
 117
 118 struct __q2d {
 119         FILE *ofp;
 120         void *q2d_all;
 121         int n;
 122 };
 123 void __output_q2d_histo(struct d_info *dip, void *arg)
 124 {
 125         struct __q2d *q2dp = arg;
 126
 127         if (q2d_ok(dip->q2d_priv)) {
 128                 char scratch[15];
 129                 FILE *ofp = q2dp->ofp;
 130
 131                 fprintf(q2dp->ofp, "%10s | ", make_dev_hdr(scratch, 15, dip));
 132                 q2d_display(ofp, dip->q2d_priv);
 133                 q2d_acc(q2dp->q2d_all, dip->q2d_priv);
 134                 q2dp->n++;
 135         }
 136 }
 137
 138 void output_q2d_histo(FILE *ofp)
 139 {
 140         struct __q2d __q2d = {
 141                 .ofp = ofp,
 142                 .q2d_all = q2d_init(),
 143                 .n = 0
 144         };
 145
 146         fprintf(ofp, "%10s | ", "DEV");
 147         q2d_display_header(ofp);
 148         fprintf(ofp, "--------- | ");
 149         q2d_display_dashes(ofp);
 150         dip_foreach_out(__output_q2d_histo, &__q2d);
 151
 152         if (__q2d.n) {
 153                 fprintf(ofp, "========== | ");
 154                 q2d_display_dashes(ofp);
 155                 fprintf(ofp, "%10s | ", "AVG");
 156                 q2d_display(ofp, __q2d.q2d_all);
 157                 fprintf(ofp, "\n");
 158         }
 159 }
 160
 161 int n_merges = 0;
 162 struct {
 163         unsigned long long nq, nd, blkmin, blkmax, total;
 164 } merge_data;
 165 void __output_dip_merge_ratio(struct d_info *dip, void *arg)
 166 {
 167         double blks_avg;
 168         char scratch[15];
 169         double ratio, q2c_n, d2c_n;
 170
 171         if (dip->n_qs == 0 || dip->n_ds == 0)
 172                 return;
 173         else if (dip->n_qs < dip->n_ds)
 174                 dip->n_qs = dip->n_ds;
 175
 176         q2c_n = dip->n_qs;
 177         d2c_n = dip->n_ds;
 178         if (q2c_n > 0.0 && d2c_n > 0.0) {
 179                 if (q2c_n < d2c_n)
 180                         ratio = 1.0;
 181                 else
 182                         ratio = q2c_n / d2c_n;
 183                 blks_avg = (double)dip->avgs.blks.total / d2c_n;
 184                 fprintf((FILE *)arg,
 185                         "%10s | %8llu %8llu %7.1lf | %8llu %8llu %8llu %8llu\n",
 186                         make_dev_hdr(scratch, 15, dip),
 187                         (unsigned long long)dip->n_qs,
 188                         (unsigned long long)dip->n_ds,
 189                         ratio,
 190                         (unsigned long long)dip->avgs.blks.min,
 191                         (unsigned long long)blks_avg,
 192                         (unsigned long long)dip->avgs.blks.max,
 193                         (unsigned long long)dip->avgs.blks.total);
 194
 195                 if (n_merges++ == 0) {
 196                         merge_data.blkmin = dip->avgs.blks.min;
 197                         merge_data.blkmax = dip->avgs.blks.max;
 198                 }
 199
 200                 merge_data.nq += dip->n_qs;
 201                 merge_data.nd += dip->n_ds;
 202                 merge_data.total += dip->avgs.blks.total;
 203                 if (dip->avgs.blks.min < merge_data.blkmin)
 204                         merge_data.blkmin = dip->avgs.blks.min;
 205                 if (dip->avgs.blks.max > merge_data.blkmax)
 206                         merge_data.blkmax = dip->avgs.blks.max;
 207         }
 208 }
 209
 210 void output_dip_merge_ratio(FILE *ofp)
 211 {
 212         fprintf(ofp, "%10s | %8s %8s %7s | %8s %8s %8s %8s\n", "DEV", "#Q", "#D", "Ratio", "BLKmin", "BLKavg", "BLKmax", "Total");
 213         fprintf(ofp, "---------- | -------- -------- ------- | -------- -------- -------- --------\n");
 214         dip_foreach_out(__output_dip_merge_ratio, ofp);
 215         if (n_merges > 1) {
 216                 fprintf(ofp, "---------- | -------- -------- ------- | -------- -------- -------- --------\n");
 217                 fprintf(ofp, "%10s | %8s %8s %7s | %8s %8s %8s %8s\n", "DEV", "#Q", "#D", "Ratio", "BLKmin", "BLKavg", "BLKmax", "Total");
 218                 fprintf((FILE *)ofp,
 219                         "%10s | %8llu %8llu %7.1lf | %8llu %8llu %8llu %8llu\n",
 220                         "TOTAL", merge_data.nq, merge_data.nd,
 221                         (float)merge_data.nq / (float)merge_data.nd,
 222                         merge_data.blkmin,
 223                         merge_data.total / merge_data.nd,
 224                         merge_data.blkmax, merge_data.total);
 225         }
 226         fprintf(ofp, "\n");
 227 }
 228
 229 struct __ohead_data {
 230         __u64 total;
 231         int n;
 232 };
 233
 234 struct ohead_data {
 235         FILE *ofp;
 236         struct __ohead_data q2g, g2i, q2m, i2d, d2c;
 237 };
 238
 239 #define AVG(a,b) (100.0 * ((double)(a) / (double)(b)))
 240 #define CALC_AVG(ap) (ap)->avg = ((ap)->n == 0 ? 0.0 :                    \
 241                                                  (BIT_TIME((ap)->total) / \
 242                                                         (double)(ap)->n))
 243
 244 #define x_v_q2C(fld, dip, s, odp)                                       \
 245         double q2c;                                                     \
 246         if (dip->avgs. fld .n == 0) return " ";                         \
 247         q2c = dip->avgs.g2i.avg + dip->avgs.g2i.avg +                   \
 248                                 dip->avgs.i2d.avg + dip->avgs.d2c.avg;  \
 249         sprintf(s, "%8.4lf%%", AVG(dip->avgs. fld .avg, q2c));          \
 250         odp-> fld .n += dip->avgs. fld .n;                              \
 251         odp-> fld .total += dip->avgs. fld .total;                      \
 252         return s;
 253
 254 char *q2g_v_q2C(struct d_info *dip, char *s, struct ohead_data *odp)
 255 {
 256         x_v_q2C(q2g, dip, s, odp);
 257 }
 258
 259 char *g2i_v_q2C(struct d_info *dip, char *s, struct ohead_data *odp)
 260 {
 261         x_v_q2C(g2i, dip, s, odp);
 262 }
 263
 264 char *q2m_v_q2C(struct d_info *dip, char *s, struct ohead_data *odp)
 265 {
 266         x_v_q2C(q2m, dip, s, odp);
 267 }
 268
 269 char *i2d_v_q2C(struct d_info *dip, char *s, struct ohead_data *odp)
 270 {
 271         x_v_q2C(i2d, dip, s, odp);
 272 }
 273
 274 char *d2c_v_q2C(struct d_info *dip, char *s, struct ohead_data *odp)
 275 {
 276         x_v_q2C(d2c, dip, s, odp);
 277 }
 278
 279 void __output_dip_prep_ohead(struct d_info *dip, void *arg)
 280 {
 281         char dev_info[15];
 282         char s1[16], s2[16], s3[16], s4[16], s5[16];
 283         struct ohead_data *odp = arg;
 284
 285         if (dip->avgs.q2g.n > 0 && dip->avgs.g2i.n > 0 &&
 286                                    dip->avgs.i2d.n > 0 && dip->avgs.d2c.n > 0) {
 287                 CALC_AVG(&dip->avgs.q2g);
 288                 CALC_AVG(&dip->avgs.g2i);
 289                 CALC_AVG(&dip->avgs.q2m);
 290                 CALC_AVG(&dip->avgs.i2d);
 291                 CALC_AVG(&dip->avgs.d2c);
 292
 293                 fprintf(odp->ofp, "%10s | %9s %9s %9s %9s %9s\n",
 294                         make_dev_hdr(dev_info, 15, dip),
 295                         q2g_v_q2C(dip, s1, odp),
 296                         g2i_v_q2C(dip, s2, odp),
 297                         q2m_v_q2C(dip, s3, odp),
 298                         i2d_v_q2C(dip, s4, odp),
 299                         d2c_v_q2C(dip, s5, odp));
 300         }
 301 }
 302
 303 #define OD_AVG(od, fld, q2c)                                            \
 304         (od. fld .n == 0) ? (double)0.0 :                               \
 305                 (100.0 * ((double)((od). fld . total) / q2c))
 306
 307 void output_dip_prep_ohead(FILE *ofp)
 308 {
 309         double q2c;
 310         struct ohead_data od;
 311
 312         memset(&od, 0, sizeof(od));
 313         od.ofp = ofp;
 314
 315         fprintf(ofp, "%10s | %9s %9s %9s %9s %9s\n",
 316                                 "DEV", "Q2G", "G2I", "Q2M", "I2D", "D2C");
 317         fprintf(ofp, "---------- | --------- --------- --------- --------- ---------\n");
 318         dip_foreach_out(__output_dip_prep_ohead, &od);
 319
 320         if (od.q2g.n == 0 && od.g2i.n == 0 && od.q2m.n == 0 &&
 321                                                 od.i2d.n == 0 && od.d2c.n == 0)
 322                 goto out;
 323
 324         q2c = od.q2g.total + od.g2i.total + od.q2m.total +
 325                                                 od.i2d.total + od.d2c.total;
 326         fprintf(ofp, "---------- | --------- --------- --------- --------- ---------\n");
 327         fprintf(ofp, "%10s | %8.4lf%% %8.4lf%% %8.4lf%% %8.4lf%% %8.4lf%%\n", "Overall",
 328                         OD_AVG(od, q2g, q2c), OD_AVG(od, g2i, q2c),
 329                         OD_AVG(od, q2m, q2c), OD_AVG(od, i2d, q2c),
 330                         OD_AVG(od, d2c, q2c));
 331
 332 out:
 333         fprintf(ofp, "\n");
 334 }
 335
 336 struct seek_mode_info {
 337         struct seek_mode_info *next;
 338         long long mode;
 339         int nseeks;
 340 };
 341 struct o_seek_info {
 342         long long nseeks, median;
 343         double mean;
 344         struct seek_mode_info *head;
 345 } seek_info;
 346 int n_seeks;
 347
 348 void output_seek_mode_info(FILE *ofp, struct o_seek_info *sip)
 349 {
 350         struct seek_mode_info *p, *this, *new_list = NULL;
 351
 352         while ((this = sip->head) != NULL) {
 353                 sip->head = this->next;
 354                 this->next = NULL;
 355
 356                 if (new_list == NULL || this->nseeks > new_list->nseeks)
 357                         new_list = this;
 358                 else if (this->nseeks == new_list->nseeks) {
 359                         for (p = new_list; p != NULL; p = p->next)
 360                                 if (p->mode == this->mode)
 361                                         break;
 362
 363                         if (p)
 364                                 this->nseeks += p->nseeks;
 365                         else
 366                                 this->next = new_list;
 367                         new_list = this;
 368                 }
 369         }
 370
 371         fprintf(ofp, "%10s | %15lld %15.1lf %15lld | %lld(%d)",
 372                 "Average", sip->nseeks, sip->mean / sip->nseeks,
 373                 sip->median / sip->nseeks, new_list->mode, new_list->nseeks);
 374
 375         for (p = new_list->next; p != NULL; p = p->next)
 376                 fprintf(ofp, " %lld(%d)", p->mode, p->nseeks);
 377 }
 378
 379 void add_seek_mode_info(struct o_seek_info *sip, struct mode *mp)
 380 {
 381         int i;
 382         long long *lp = mp->modes;
 383         struct seek_mode_info *smip;
 384
 385         n_seeks++;
 386         for (i = 0; i < mp->nmds; i++, lp++) {
 387                 for (smip = sip->head; smip; smip = smip->next) {
 388                         if (smip->mode == *lp) {
 389                                 smip->nseeks += mp->most_seeks;
 390                                 break;
 391                         }
 392                 }
 393                 if (!smip) {
 394                         struct seek_mode_info *new = malloc(sizeof(*new));
 395
 396                         new->next = sip->head;
 397                         sip->head = new;
 398                         new->mode = *lp;
 399                         new->nseeks = mp->most_seeks;
 400
 401                         add_buf(new);
 402                 }
 403         }
 404 }
 405
 406 static void do_output_dip_seek_info(struct d_info *dip, FILE *ofp, int is_q2q)
 407 {
 408         double mean;
 409         int i, nmodes;
 410         long long nseeks;
 411         char dev_info[15];
 412         long long median;
 413         struct mode m;
 414         void *handle = is_q2q ? dip->q2q_handle : dip->seek_handle;
 415
 416         nseeks = seeki_nseeks(handle);
 417         if (nseeks > 0) {
 418                 mean = seeki_mean(handle);
 419                 median = seeki_median(handle);
 420                 nmodes = seeki_mode(handle, &m);
 421
 422                 fprintf(ofp, "%10s | %15lld %15.1lf %15lld | %lld(%d)",
 423                         make_dev_hdr(dev_info, 15, dip), nseeks, mean, median,
 424                         nmodes > 0 ? m.modes[0] : 0, m.most_seeks);
 425                 for (i = 1; i < nmodes; i++)
 426                         fprintf(ofp, " %lld", m.modes[i]);
 427                 fprintf(ofp, "\n");
 428
 429                 seek_info.nseeks += nseeks;
 430                 seek_info.mean += (nseeks * mean);
 431                 seek_info.median += (nseeks * median);
 432                 add_seek_mode_info(&seek_info, &m);
 433                 free(m.modes);
 434         }
 435 }
 436
 437 void __output_dip_seek_info(struct d_info *dip, void *arg)
 438 {
 439         do_output_dip_seek_info(dip, (FILE *)arg, 0);
 440 }
 441
 442 void __output_dip_q2q_seek_info(struct d_info *dip, void *arg)
 443 {
 444         do_output_dip_seek_info(dip, (FILE *)arg, 1);
 445 }
 446
 447 void output_dip_seek_info(FILE *ofp)
 448 {
 449         n_seeks = 1;
 450         memset(&seek_info, 0, sizeof(seek_info));
 451
 452         fprintf(ofp, "%10s | %15s %15s %15s | %-15s\n", "DEV", "NSEEKS",
 453                         "MEAN", "MEDIAN", "MODE");
 454         fprintf(ofp, "---------- | --------------- --------------- --------------- | ---------------\n");
 455         dip_foreach_out(__output_dip_seek_info, ofp);
 456         if (n_seeks > 1) {
 457                 fprintf(ofp, "---------- | --------------- --------------- --------------- | ---------------\n");
 458                 fprintf(ofp, "%10s | %15s %15s %15s | %-15s\n",
 459                         "Overall", "NSEEKS", "MEAN", "MEDIAN", "MODE");
 460                 output_seek_mode_info(ofp, &seek_info);
 461                 fprintf(ofp, "\n");
 462         }
 463         fprintf(ofp, "\n");
 464 }
 465
 466 void output_dip_q2q_seek_info(FILE *ofp)
 467 {
 468         n_seeks = 1;
 469         memset(&seek_info, 0, sizeof(seek_info));
 470
 471         fprintf(ofp, "%10s | %15s %15s %15s | %-15s\n", "DEV", "NSEEKS",
 472                         "MEAN", "MEDIAN", "MODE");
 473         fprintf(ofp, "---------- | --------------- --------------- --------------- | ---------------\n");
 474         dip_foreach_out(__output_dip_q2q_seek_info, ofp);
 475         if (n_seeks > 1) {
 476                 fprintf(ofp, "---------- | --------------- --------------- --------------- | ---------------\n");
 477                 fprintf(ofp, "%10s | %15s %15s %15s | %-15s\n",
 478                         "Overall", "NSEEKS", "MEAN", "MEDIAN", "MODE");
 479                 output_seek_mode_info(ofp, &seek_info);
 480                 fprintf(ofp, "\n");
 481         }
 482         fprintf(ofp, "\n");
 483 }
 484
 485 struct __opa {
 486         FILE *ofp;
 487         ai_pip_t (*func)(struct p_info *);
 488 };
 489
 490 void __output_pip_avg(struct p_info *pip, void *arg)
 491 {
 492         struct __opa *opap = arg;
 493         ai_pip_t ap = opap->func(pip);
 494
 495         if (ap->n > 0) {
 496                 char proc_name[15];
 497                 snprintf(proc_name, 15, pip->name);
 498
 499                 ap->avg = BIT_TIME(ap->total) / (double)ap->n;
 500                 __output_avg(opap->ofp, proc_name, ap);
 501         }
 502 }
 503
 504 void output_pip_avg(FILE *ofp, char *hdr, ai_pip_t (*func)(struct p_info *))
 505 {
 506         struct __opa opa = { .ofp = ofp, .func = func };
 507
 508         output_hdr(ofp, hdr);
 509         pip_foreach_out(__output_pip_avg, &opa);
 510         fprintf(ofp, "\n");
 511 }
 512
 513 int n_plugs;
 514 struct plug_info {
 515         long n_plugs, n_timer_unplugs;
 516         double t_percent;
 517 } plug_info;
 518
 519 void __dip_output_plug(struct d_info *dip, void *arg)
 520 {
 521         char dev_info[15];
 522         FILE *ofp = arg;
 523         double delta, pct;
 524
 525         if (dip->nplugs > 0) {
 526                 if (dip->is_plugged) dip_unplug(dip->device, dip->end_time, 0);
 527                 delta = dip->end_time - dip->start_time;
 528                 pct = 100.0 * ((dip->plugged_time / delta) / delta);
 529
 530                 fprintf(ofp, "%10s | %10d(%10d) | %13.9lf%%\n",
 531                         make_dev_hdr(dev_info, 15, dip),
 532                         dip->nplugs, dip->n_timer_unplugs, pct);
 533
 534                 n_plugs++;
 535                 plug_info.n_plugs += dip->nplugs;
 536                 plug_info.n_timer_unplugs += dip->n_timer_unplugs;
 537                 plug_info.t_percent += pct;
 538         }
 539 }
 540
 541 void __dip_output_plug_all(FILE *ofp, struct plug_info *p)
 542 {
 543         fprintf(ofp, "---------- | ---------- ----------  | ----------------\n");
 544         fprintf(ofp, "%10s | %10s %10s  | %s\n",
 545                 "Overall", "# Plugs", "# Timer Us", "% Time Q Plugged");
 546         fprintf(ofp, "%10s | %10ld(%10ld) | %13.9lf%%\n", "Average",
 547                 p->n_plugs / n_plugs, p->n_timer_unplugs / n_plugs,
 548                 p->t_percent / n_plugs);
 549
 550 }
 551
 552 __u64 n_nios_uplugs, n_nios_uplugs_t;
 553 struct nios_plug_info {
 554         __u64 tot_nios_up, tot_nios_up_t;
 555 } nios_plug_info;
 556
 557 void __dip_output_plug_nios(struct d_info *dip, void *arg)
 558 {
 559         char dev_info[15];
 560         FILE *ofp = arg;
 561         double a_nios_uplug = 0.0, a_nios_uplug_t = 0.0;
 562
 563         if (dip->nios_up && dip->nplugs) {
 564                 a_nios_uplug = (double)dip->nios_up / (double)dip->nplugs;
 565                 n_nios_uplugs += dip->nplugs;
 566                 nios_plug_info.tot_nios_up += dip->nios_up;
 567         }
 568         if (dip->nios_upt && dip->nplugs_t) {
 569                 a_nios_uplug_t = (double)dip->nios_upt / (double)dip->nplugs_t;
 570                 n_nios_uplugs_t += dip->nplugs_t;
 571                 nios_plug_info.tot_nios_up_t += dip->nios_upt;
 572         }
 573
 574         fprintf(ofp, "%10s | %10.1lf   %10.1lf\n",
 575                 make_dev_hdr(dev_info, 15, dip),
 576                 a_nios_uplug, a_nios_uplug_t);
 577 }
 578
 579 void __dip_output_uplug_all(FILE *ofp, struct nios_plug_info *p)
 580 {
 581         double ios_unp = 0.0, ios_unp_to = 0.0;
 582
 583         if (n_nios_uplugs)
 584                 ios_unp = (double)p->tot_nios_up / (double)n_nios_uplugs;
 585         if (n_nios_uplugs_t)
 586                 ios_unp_to = (double)p->tot_nios_up_t / (double)n_nios_uplugs_t;
 587
 588         fprintf(ofp, "---------- | ----------   ----------\n");
 589         fprintf(ofp, "%10s | %10s   %10s\n",
 590                 "Overall", "IOs/Unp", "IOs/Unp(to)");
 591         fprintf(ofp, "%10s | %10.1lf   %10.1lf\n",
 592                 "Average", ios_unp, ios_unp_to);
 593 }
 594
 595 void output_plug_info(FILE *ofp)
 596 {
 597         fprintf(ofp, "%10s | %10s %10s  | %s\n",
 598                 "DEV", "# Plugs", "# Timer Us", "% Time Q Plugged");
 599         fprintf(ofp, "---------- | ---------- ----------  | ----------------\n");
 600         dip_foreach_out(__dip_output_plug, ofp);
 601         if (n_plugs > 1)
 602                 __dip_output_plug_all(ofp, &plug_info);
 603         fprintf(ofp, "\n");
 604
 605         fprintf(ofp, "%10s | %10s   %10s\n",
 606                 "DEV", "IOs/Unp", "IOs/Unp(to)");
 607         fprintf(ofp, "---------- | ----------   ----------\n");
 608         dip_foreach_out(__dip_output_plug_nios, ofp);
 609         if (n_nios_uplugs || n_nios_uplugs_t)
 610                 __dip_output_uplug_all(ofp, &nios_plug_info);
 611         fprintf(ofp, "\n");
 612 }
 613
 614 int n_actQs;
 615 struct actQ_info {
 616         __u64 t_qs;
 617         __u64 t_act_qs;
 618 } actQ_info;
 619
 620 void __dip_output_actQ(struct d_info *dip, void *arg)
 621 {
 622         if (dip->n_qs > 0 && !remapper_dev(dip->device)) {
 623                 char dev_info[15];
 624                 double a_actQs = (double)dip->t_act_q / (double)dip->n_qs;
 625
 626                 fprintf((FILE *)arg, "%10s | %13.1lf\n",
 627                         make_dev_hdr(dev_info, 15, dip), a_actQs);
 628
 629                 n_actQs++;
 630                 actQ_info.t_qs += dip->n_qs;
 631                 actQ_info.t_act_qs += dip->t_act_q;
 632         }
 633 }
 634
 635 void __dip_output_actQ_all(FILE *ofp, struct actQ_info *p)
 636 {
 637         fprintf(ofp, "---------- | -------------\n");
 638         fprintf(ofp, "%10s | %13s\n", "Overall", "Avgs Reqs @ Q");
 639         fprintf(ofp, "%10s | %13.1lf\n", "Average",
 640                 (double)p->t_act_qs / (double)p->t_qs);
 641 }
 642
 643 void output_actQ_info(FILE *ofp)
 644 {
 645         fprintf(ofp, "%10s | %13s\n", "DEV", "Avg Reqs @ Q");
 646         fprintf(ofp, "---------- | -------------\n");
 647         dip_foreach_out(__dip_output_actQ, ofp);
 648         if (n_actQs > 1)
 649                 __dip_output_actQ_all(ofp, &actQ_info);
 650         fprintf(ofp, "\n");
 651 }
 652
 653 void output_histos(void)
 654 {
 655         int i;
 656         FILE *ofp;
 657         char fname[256];
 658
 659         if (output_name == NULL) return;
 660
 661         sprintf(fname, "%s_qhist.dat", output_name);
 662         ofp = fopen(fname, "w");
 663         if (!ofp) {
 664                 perror(fname);
 665                 return;
 666         }
 667
 668         fprintf(ofp, "# BTT histogram data\n");
 669         fprintf(ofp, "# Q buckets\n");
 670         for (i = 0; i < (N_HIST_BKTS-1); i++)
 671                 fprintf(ofp, "%4d %lld\n", (i+1), (long long)q_histo[i]);
 672         fprintf(ofp, "\n# Q bucket for > %d\n%4d %lld\n", (int)N_HIST_BKTS-1,
 673                 N_HIST_BKTS-1, (long long)q_histo[N_HIST_BKTS-1]);
 674         fclose(ofp);
 675
 676         sprintf(fname, "%s_dhist.dat", output_name);
 677         ofp = fopen(fname, "w");
 678         if (!ofp) {
 679                 perror(fname);
 680                 return;
 681         }
 682         fprintf(ofp, "# D buckets\n");
 683         for (i = 0; i < (N_HIST_BKTS-1); i++)
 684                 fprintf(ofp, "%4d %lld\n", (i+1), (long long)d_histo[i]);
 685         fprintf(ofp, "\n# D bucket for > %d\n%4d %lld\n", (int)N_HIST_BKTS-1,
 686                 N_HIST_BKTS-1, (long long)d_histo[N_HIST_BKTS-1]);
 687         fclose(ofp);
 688 }
 689
 690 int output_avgs(FILE *ofp)
 691 {
 692         if (output_all_data) {
 693                 if (exes == NULL || *exes != '\0') {
 694                         output_section_hdr(ofp, "Per Process");
 695                         output_pip_avg(ofp, "Q2Qdm", pip_q2q_dm_avg);
 696                         output_pip_avg(ofp, "Q2Adm", pip_q2a_dm_avg);
 697                         output_pip_avg(ofp, "Q2Cdm", pip_q2c_dm_avg);
 698                         fprintf(ofp, "\n");
 699
 700                         output_pip_avg(ofp, "Q2Q", pip_q2q_avg);
 701                         output_pip_avg(ofp, "Q2A", pip_q2a_avg);
 702                         output_pip_avg(ofp, "Q2G", pip_q2g_avg);
 703                         output_pip_avg(ofp, "G2I", pip_g2i_avg);
 704                         output_pip_avg(ofp, "Q2M", pip_q2m_avg);
 705                         output_pip_avg(ofp, "I2D", pip_i2d_avg);
 706                         output_pip_avg(ofp, "D2C", pip_d2c_avg);
 707                         output_pip_avg(ofp, "Q2C", pip_q2c_avg);
 708                 }
 709
 710                 output_section_hdr(ofp, "Per Device");
 711                 output_dip_avg(ofp, "Q2Qdm", dip_q2q_dm_avg);
 712                 output_dip_avg(ofp, "Q2Adm", dip_q2a_dm_avg);
 713                 output_dip_avg(ofp, "Q2Cdm", dip_q2c_dm_avg);
 714                 fprintf(ofp, "\n");
 715
 716                 output_dip_avg(ofp, "Q2Q", dip_q2q_avg);
 717                 output_dip_avg(ofp, "Q2A", dip_q2a_avg);
 718                 output_dip_avg(ofp, "Q2G", dip_q2g_avg);
 719                 output_dip_avg(ofp, "G2I", dip_g2i_avg);
 720                 output_dip_avg(ofp, "Q2M", dip_q2m_avg);
 721                 output_dip_avg(ofp, "I2D", dip_i2d_avg);
 722                 output_dip_avg(ofp, "D2C", dip_d2c_avg);
 723                 output_dip_avg(ofp, "Q2C", dip_q2c_avg);
 724         }
 725
 726         output_section_hdr(ofp, "All Devices");
 727         output_hdr(ofp, "ALL");
 728         __output_avg(ofp, "Q2Qdm", &all_avgs.q2q_dm);
 729         __output_avg(ofp, "Q2Adm", &all_avgs.q2a_dm);
 730         __output_avg(ofp, "Q2Cdm", &all_avgs.q2c_dm);
 731         fprintf(ofp, "\n");
 732
 733         __output_avg(ofp, "Q2Q", &all_avgs.q2q);
 734         __output_avg(ofp, "Q2A", &all_avgs.q2a);
 735         __output_avg(ofp, "Q2G", &all_avgs.q2g);
 736         __output_avg(ofp, "G2I", &all_avgs.g2i);
 737         __output_avg(ofp, "Q2M", &all_avgs.q2m);
 738         __output_avg(ofp, "I2D", &all_avgs.i2d);
 739         __output_avg(ofp, "M2D", &all_avgs.m2d);
 740         __output_avg(ofp, "D2C", &all_avgs.d2c);
 741         __output_avg(ofp, "Q2C", &all_avgs.q2c);
 742         fprintf(ofp, "\n");
 743
 744         output_section_hdr(ofp, "Device Overhead");
 745         output_dip_prep_ohead(ofp);
 746
 747         output_section_hdr(ofp, "Device Merge Information");
 748         output_dip_merge_ratio(ofp);
 749
 750         output_section_hdr(ofp, "Device Q2Q Seek Information");
 751         output_dip_q2q_seek_info(ofp);
 752
 753         output_section_hdr(ofp, "Device D2D Seek Information");
 754         output_dip_seek_info(ofp);
 755
 756         output_section_hdr(ofp, "Plug Information");
 757         output_plug_info(ofp);
 758
 759         output_section_hdr(ofp, "Active Requests At Q Information");
 760         output_actQ_info(ofp);
 761
 762         output_histos();
 763
 764         if (output_all_data) {
 765                 output_section_hdr(ofp, "Q2D Histogram");
 766                 output_q2d_histo(ofp);
 767         }
 768
 769         return 0;
 770 }
 771
 772 void __output_ranges(FILE *ofp, struct list_head *head_p, float base)
 773 {
 774         struct range_info *rip;
 775         struct list_head *p;
 776         float limit = base + 0.4;
 777
 778         __list_for_each(p, head_p) {
 779                 rip = list_entry(p, struct range_info, head);
 780                 fprintf(ofp, "%13.9lf %5.1f\n", BIT_TIME(rip->start), base);
 781                 fprintf(ofp, "%13.9lf %5.1f\n", BIT_TIME(rip->start), limit);
 782                 fprintf(ofp, "%13.9lf %5.1f\n", BIT_TIME(rip->end), limit);
 783                 fprintf(ofp, "%13.9lf %5.1f\n", BIT_TIME(rip->end), base);
 784         }
 785 }
 786
 787 int output_regions(FILE *ofp, char *header, struct region_info *reg,
 788                           float base)
 789 {
 790         if (list_len(&reg->qranges) == 0 && list_len(&reg->cranges) == 0)
 791                 return 0;
 792
 793         fprintf(ofp, "# %16s : q activity\n", header);
 794         __output_ranges(ofp, &reg->qranges, base);
 795         fprintf(ofp, "\n");
 796
 797         fprintf(ofp, "# %16s : c activity\n", header);
 798         __output_ranges(ofp, &reg->cranges, base + 0.5);
 799         fprintf(ofp, "\n");
 800
 801         return 1;
 802 }
 803
 804 struct __od {
 805         FILE *ofp;
 806         float base;
 807 };
 808 void __output_dev(struct d_info *dip, void *arg)
 809 {
 810         char header[128];
 811         struct __od *odp = arg;
 812
 813         sprintf(header, "%d,%d", MAJOR(dip->device), MINOR(dip->device));
 814         if (output_regions(odp->ofp, header, &dip->regions, odp->base))
 815                 odp->base += 1.0;
 816 }
 817
 818 float output_devs(FILE *ofp, float base)
 819 {
 820         struct __od od = { .ofp = ofp, .base = base };
 821
 822         fprintf(ofp, "# Per device\n" );
 823         dip_foreach_out(__output_dev, &od);
 824         return od.base;
 825 }
 826
 827 static inline int exe_match(char *exe, char *name)
 828 {
 829         return (exe == NULL) || (strstr(name, exe) != NULL);
 830 }
 831
 832 struct __op {
 833         FILE *ofp;
 834         float base;
 835 };
 836 void __output_procs(struct p_info *pip, void *arg)
 837 {
 838         struct __op *opp = arg;
 839         output_regions(opp->ofp, pip->name, &pip->regions, opp->base);
 840         opp->base += 1.0;
 841 }
 842
 843 float output_procs(FILE *ofp, float base)
 844 {
 845         struct __op op = { .ofp = ofp, .base = base };
 846
 847         fprintf(ofp, "# Per process\n" );
 848         pip_foreach_out(__output_procs, &op);
 849         return op.base;
 850 }
 851
 852 int output_ranges(FILE *ofp)
 853 {
 854         float base = 0.0;
 855
 856         fprintf(ofp, "# %s\n", "Total System");
 857         if (output_regions(ofp, "Total System", &all_regions, base))
 858                 base += 1.0;
 859
 860         if (n_devs > 1)
 861                 base = output_devs(ofp, base);
 862
 863         base = output_procs(ofp, base);
 864
 865         return 0;
 866 }