btt/iostat.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 <unistd.h>
  23 #include "globals.h"
  24
  25 #define INC_STAT(dip, fld)                                              \
  26         do {                                                            \
  27                 (dip)->stats. fld ++;                                   \
  28                 (dip)->all_stats. fld ++;                               \
  29         } while (0)
  30
  31 #define DEC_STAT(dip, fld)                                              \
  32         do {                                                            \
  33                 (dip)->stats. fld --;                                   \
  34                 (dip)->all_stats. fld --;                               \
  35         } while (0)
  36
  37 #define ADD_STAT(dip, fld, val)                                         \
  38          do {                                                           \
  39                  __u64 __v = (val);                                     \
  40                 (dip)->stats. fld += __v;                               \
  41                 (dip)->all_stats. fld += __v;                           \
  42         } while (0)
  43
  44 #define SUB_STAT(dip, fld, val)                                         \
  45          do {                                                           \
  46                  __u64 __v = (val);                                     \
  47                 (dip)->stats. fld -= __v;                               \
  48                 (dip)->all_stats. fld -= __v;                           \
  49         } while (0)
  50
  51 __u64 last_start, iostat_last_stamp;
  52 __u64 iostat_interval = 1000000000;
  53 char *iostat_name = NULL;
  54 FILE *iostat_ofp = NULL;
  55
  56 void dump_hdr(void)
  57 {
  58         fprintf(iostat_ofp, "Device:       rrqm/s   wrqm/s     r/s     w/s    "
  59                             "rsec/s    wsec/s     rkB/s     wkB/s "
  60                             "avgrq-sz avgqu-sz   await   svctm  %%util   Stamp\n");
  61 }
  62
  63 void iostat_init(void)
  64 {
  65         last_start = (__u64)-1;
  66         if (iostat_ofp)
  67                 dump_hdr();
  68 }
  69
  70 void update_tot_qusz(struct d_info *dip, double now)
  71 {
  72         dip->stats.tot_qusz += ((now - dip->stats.last_qu_change) *
  73                                                 dip->stats.cur_qusz);
  74         dip->all_stats.tot_qusz += ((now - dip->all_stats.last_qu_change) *
  75                                                 dip->all_stats.cur_qusz);
  76
  77         dip->stats.last_qu_change = dip->all_stats.last_qu_change = now;
  78 }
  79
  80 void update_idle_time(struct d_info *dip, double now, int force)
  81 {
  82         if (dip->stats.cur_dev == 0 || force) {
  83                 dip->stats.idle_time += (now - dip->stats.last_dev_change);
  84                 dip->all_stats.idle_time +=
  85                                        (now - dip->all_stats.last_dev_change);
  86         }
  87         dip->stats.last_dev_change = dip->all_stats.last_dev_change = now;
  88 }
  89
  90 void __dump_stats(__u64 stamp, int all, struct d_info *dip, struct stats_t *asp)
  91 {
  92         char hdr[16];
  93         struct stats *sp;
  94         double dt, nios, avgrq_sz, p_util, nrqm, await, svctm;
  95         double now = TO_SEC(stamp);
  96
  97         if (all) {
  98                 dt = (double)stamp / 1.0e9;
  99                 sp = &dip->all_stats;
 100         }
 101         else {
 102                 dt = (double)(stamp-last_start) / 1.0e9;
 103                 sp = &dip->stats;
 104         }
 105
 106         nios = (double)(sp->ios[0] + sp->ios[1]);
 107         nrqm = (double)(sp->rqm[0] + sp->rqm[1]);
 108         update_idle_time(dip, now, 1);
 109         update_tot_qusz(dip, now);
 110
 111         if (nios > 0.0) {
 112                 avgrq_sz = (double)(sp->sec[0] + sp->sec[1]) / nios;
 113                 svctm = TO_MSEC(sp->svctm) / nios;
 114         }
 115         else
 116                 avgrq_sz = svctm = 0.0;
 117
 118         await = ((nios + nrqm) > 0.0) ? TO_MSEC(sp->wait) / (nios+nrqm) : 0.0;
 119         p_util = (sp->idle_time <= dt) ? 100.0 * (1.0 - (sp->idle_time / dt)) :
 120                                          0.0;
 121
 122         /*
 123          * For AWAIT: nios should be the same as number of inserts
 124          * and we add in nrqm (number of merges), which should give
 125          * us the total number of IOs sent to the block IO layer.
 126          */
 127         fprintf(iostat_ofp, "%-11s ", make_dev_hdr(hdr, 11, dip));
 128         fprintf(iostat_ofp, "%8.2lf ", (double)sp->rqm[1] / dt);
 129         fprintf(iostat_ofp, "%8.2lf ", (double)sp->rqm[0] / dt);
 130         fprintf(iostat_ofp, "%7.2lf ", (double)sp->ios[1] / dt);
 131         fprintf(iostat_ofp, "%7.2lf ", (double)sp->ios[0] / dt);
 132         fprintf(iostat_ofp, "%9.2lf ", (double)sp->sec[1] / dt);
 133         fprintf(iostat_ofp, "%9.2lf ", (double)sp->sec[0] / dt);
 134         fprintf(iostat_ofp, "%9.2lf ", (double)(sp->sec[1] / 2) / dt);
 135         fprintf(iostat_ofp, "%9.2lf ", (double)(sp->sec[0] / 2) / dt);
 136         fprintf(iostat_ofp, "%8.2lf ", avgrq_sz);
 137         fprintf(iostat_ofp, "%8.2lf ", (double)sp->tot_qusz / dt);
 138         fprintf(iostat_ofp, "%7.2lf ", await);
 139         fprintf(iostat_ofp, "%7.2lf ", svctm);
 140         fprintf(iostat_ofp, "%6.2lf", p_util);
 141         if (all)
 142                 fprintf(iostat_ofp, "%8s\n", "TOTAL");
 143         else {
 144                 fprintf(iostat_ofp, "%8.2lf\n", TO_SEC(stamp));
 145                 sp->rqm[0] = sp->rqm[1] = 0;
 146                 sp->ios[0] = sp->ios[1] = 0;
 147                 sp->sec[0] = sp->sec[1] = 0;
 148                 sp->wait = sp->svctm = 0;
 149
 150                 sp->tot_qusz = sp->idle_time = 0.0;
 151         }
 152
 153         if (asp) {
 154                 int i;
 155
 156                 asp->n += 1.0;
 157                 for (i = 0; i < 2; i++) {
 158                         asp->rqm_s[i] += ((double)sp->rqm[i] / dt);
 159                         asp->ios_s[i] += ((double)sp->ios[i] / dt);
 160                         asp->sec_s[i] += ((double)sp->sec[i] / dt);
 161                 }
 162                 asp->avgrq_sz += avgrq_sz;
 163                 asp->avgqu_sz += (double)sp->tot_qusz / dt;
 164                 asp->await += await;
 165                 asp->svctm += svctm;
 166                 asp->p_util += p_util;
 167         }
 168 }
 169
 170 void __dump_stats_t(__u64 stamp, struct stats_t *asp, int all)
 171 {
 172         if (asp->n < 2.0) return;       // What's the point?
 173
 174         fprintf(iostat_ofp, "%-11s ", "TOTAL");
 175         fprintf(iostat_ofp, "%8.2lf ", asp->rqm_s[0]);
 176         fprintf(iostat_ofp, "%8.2lf ", asp->rqm_s[1]);
 177         fprintf(iostat_ofp, "%7.2lf ", asp->ios_s[0]);
 178         fprintf(iostat_ofp, "%7.2lf ", asp->ios_s[1]);
 179         fprintf(iostat_ofp, "%9.2lf ", asp->sec_s[0]);
 180         fprintf(iostat_ofp, "%9.2lf ", asp->sec_s[1]);
 181         fprintf(iostat_ofp, "%9.2lf ", asp->sec_s[0] / 2.0);
 182         fprintf(iostat_ofp, "%9.2lf ", asp->sec_s[1] / 2.0);
 183         fprintf(iostat_ofp, "%8.2lf ", asp->avgrq_sz / asp->n);
 184         fprintf(iostat_ofp, "%8.2lf ", asp->avgqu_sz / asp->n);
 185         fprintf(iostat_ofp, "%7.2lf ", asp->await / asp->n);
 186         fprintf(iostat_ofp, "%7.2lf ", asp->svctm / asp->n);
 187         fprintf(iostat_ofp, "%6.2lf", asp->p_util / asp->n);
 188         if (all)
 189                 fprintf(iostat_ofp, "%8s\n", "TOTAL");
 190         else
 191                 fprintf(iostat_ofp, "%8.2lf\n", TO_SEC(stamp));
 192 }
 193
 194 void iostat_dump_stats(__u64 stamp, int all)
 195 {
 196         struct d_info *dip;
 197         struct stats_t as;
 198
 199         memset(&as, 0, sizeof(struct stats_t));
 200         if (all)
 201                 dump_hdr();
 202
 203         if (devices == NULL) {
 204                 struct list_head *p;
 205
 206                 __list_for_each(p, &all_devs) {
 207                         dip = list_entry(p, struct d_info, all_head);
 208                         __dump_stats(stamp, all, dip, &as);
 209                 }
 210         }
 211         else {
 212                 int i;
 213                 unsigned int mjr, mnr;
 214                 char *p = devices;
 215
 216                 while (p && ((i = sscanf(p, "%u,%u", &mjr, &mnr)) == 2)) {
 217                         dip = __dip_find((__u32)((mjr << MINORBITS) | mnr));
 218                         __dump_stats(stamp, all, dip, &as);
 219
 220                         p = strchr(p, ';');
 221                         if (p) p++;
 222                 }
 223         }
 224
 225         __dump_stats_t(stamp, &as, all);
 226
 227         if (!all && iostat_ofp)
 228                 fprintf(iostat_ofp, "\n");
 229 }
 230
 231 void iostat_check_time(__u64 stamp)
 232 {
 233         if (iostat_ofp) {
 234                 if (last_start == (__u64)-1)
 235                         last_start = stamp;
 236                 else if ((stamp - last_start) >= iostat_interval) {
 237                         iostat_dump_stats(stamp, 0);
 238                         last_start = stamp;
 239                 }
 240
 241                 iostat_last_stamp = stamp;
 242         }
 243 }
 244
 245 void iostat_getrq(struct io *iop)
 246 {
 247         update_tot_qusz(iop->dip, TO_SEC(iop->t.time));
 248         INC_STAT(iop->dip, cur_qusz);
 249 }
 250
 251 void iostat_merge(struct io *iop)
 252 {
 253         INC_STAT(iop->dip, rqm[IOP_RW(iop)]);
 254 }
 255
 256 void iostat_issue(struct io *iop)
 257 {
 258         int rw = IOP_RW(iop);
 259         struct d_info *dip = iop->dip;
 260         double now = TO_SEC(iop->t.time);
 261
 262         INC_STAT(dip, ios[rw]);
 263         ADD_STAT(dip, sec[rw], iop->t.bytes >> 9);
 264
 265         update_idle_time(dip, now, 0);
 266         INC_STAT(dip, cur_dev);
 267 }
 268
 269 void iostat_unissue(struct io *iop)
 270 {
 271         int rw = IOP_RW(iop);
 272         struct d_info *dip = iop->dip;
 273
 274         DEC_STAT(dip, ios[rw]);
 275         SUB_STAT(dip, sec[rw], iop->t.bytes >> 9);
 276         DEC_STAT(dip, cur_dev);
 277 }
 278
 279 void iostat_complete(struct io *q_iop, struct io *c_iop)
 280 {
 281         double now = TO_SEC(c_iop->t.time);
 282         struct d_info *dip = q_iop->dip;
 283
 284         if (q_iop->i_time != (__u64)-1)
 285                 ADD_STAT(c_iop->dip, wait, tdelta(q_iop->i_time,c_iop->t.time));
 286         else if (q_iop->m_time != (__u64)-1)
 287                 ADD_STAT(c_iop->dip, wait, tdelta(q_iop->m_time,c_iop->t.time));
 288
 289         update_tot_qusz(dip, now);
 290         DEC_STAT(dip, cur_qusz);
 291
 292         update_idle_time(dip, now, 0);
 293         DEC_STAT(dip, cur_dev);
 294
 295         ADD_STAT(dip, svctm, tdelta(q_iop->t.time, c_iop->t.time));
 296 }