usr.bin/evtranalyze/evtranalyze.c

   1 /*
   2  * Copyright (c) 2009, 2010 Aggelos Economopoulos.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in
  12  *    the documentation and/or other materials provided with the
  13  *    distribution.
  14  * 3. Neither the name of The DragonFly Project nor the names of its
  15  *    contributors may be used to endorse or promote products derived
  16  *    from this software without specific, prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  21  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  22  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  23  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  24  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  25  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  26  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  27  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  28  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 #include <assert.h>
  33 #include <ctype.h>
  34 #include <err.h>
  35 #include <inttypes.h>
  36 #include <libgen.h>
  37 #include <math.h>
  38 #include <stdio.h>
  39 #include <stdlib.h>
  40 #include <string.h>
  41 #include <unistd.h>
  42
  43 #include <evtr.h>
  44 #include "xml.h"
  45 #include "svg.h"
  46 #include "plotter.h"
  47 #include "trivial.h"
  48
  49 enum {
  50         NR_TOP_THREADS = 5,
  51         NR_BUCKETS = 1021,
  52 };
  53
  54 struct rows {
  55         double row_increment;
  56         double row_off;
  57 };
  58
  59 #define CMD_PROTO(name) \
  60         static int cmd_ ## name(int, char **)
  61
  62 CMD_PROTO(show);
  63 CMD_PROTO(svg);
  64 CMD_PROTO(stats);
  65 CMD_PROTO(summary);
  66
  67 struct command {
  68         const char *name;
  69         int (*func)(int argc, char **argv);
  70 } commands[] = {
  71         {
  72                 .name = "show",
  73                 .func = &cmd_show,
  74         },
  75         {
  76                 .name = "svg",
  77                 .func = &cmd_svg,
  78         },
  79         {
  80                 .name = "stats",
  81                 .func = &cmd_stats,
  82         },
  83         {
  84                 .name = "summary",
  85                 .func = &cmd_summary,
  86         },
  87         {
  88                 .name = NULL,
  89         },
  90 };
  91
  92 evtr_t evtr;
  93 static char *opt_infile;
  94 unsigned evtranalyze_debug;
  95
  96 static
  97 void
  98 printd_set_flags(const char *str, unsigned int *flags)
  99 {
 100         /*
 101          * This is suboptimal as we don't detect
 102          * invalid flags.
 103          */
 104         for (; *str; ++str) {
 105                 if ('A' == *str) {
 106                         *flags = -1;
 107                         return;
 108                 }
 109                 if (!islower(*str))
 110                         err(2, "invalid debug flag %c\n", *str);
 111                 *flags |= 1 << (*str - 'a');
 112         }
 113 }
 114
 115 struct hashentry {
 116         uintptr_t key;
 117         uintptr_t val;
 118         struct hashentry *next;
 119 };
 120
 121 struct hashtab {
 122         struct hashentry *buckets[NR_BUCKETS];
 123         uintptr_t (*hashfunc)(uintptr_t);
 124         uintptr_t (*cmpfunc)(uintptr_t, uintptr_t);
 125 };
 126
 127 static int
 128 ehash_find(const struct hashtab *tab, uintptr_t key, uintptr_t *val)
 129 {
 130         struct hashentry *ent;
 131
 132         for(ent = tab->buckets[tab->hashfunc(key)];
 133             ent && tab->cmpfunc(ent->key, key);
 134             ent = ent->next);
 135
 136         if (!ent)
 137                 return !0;
 138         *val = ent->val;
 139         return 0;
 140 }
 141
 142 static struct hashentry *
 143 ehash_insert(struct hashtab *tab, uintptr_t key, uintptr_t val)
 144 {
 145         struct hashentry *ent;
 146         int hsh;
 147
 148         if (!(ent = malloc(sizeof(*ent)))) {
 149                 fprintf(stderr, "out of memory\n");
 150                 return NULL;
 151         }
 152         hsh = tab->hashfunc(key);
 153         ent->next = tab->buckets[hsh];
 154         ent->key = key;
 155         ent->val = val;
 156         tab->buckets[hsh] = ent;
 157         return ent;
 158 }
 159 static
 160 int
 161 ehash_delete(struct hashtab *tab, uintptr_t key)
 162 {
 163         struct hashentry *ent, *prev;
 164
 165         prev = NULL;
 166         for(ent = tab->buckets[tab->hashfunc(key)];
 167             ent && tab->cmpfunc(ent->key, key);
 168             prev = ent, ent = ent->next);
 169         if (!ent)
 170                 return !0;
 171         if (prev)
 172                 prev->next = ent->next;
 173         else
 174                 tab->buckets[tab->hashfunc(key)] = ent->next;
 175         free(ent);
 176         return 0;
 177 }
 178
 179 static
 180 uintptr_t
 181 cmpfunc_pointer(uintptr_t a, uintptr_t b)
 182 {
 183         return b - a;
 184 }
 185
 186 static
 187 uintptr_t
 188 hashfunc_pointer(uintptr_t p)
 189 {
 190         return p % NR_BUCKETS;
 191 }
 192
 193 static
 194 uintptr_t
 195 hashfunc_string(uintptr_t p)
 196 {
 197         const char *str = (char *)p;
 198         unsigned long hash = 5381;
 199         int c;
 200
 201         while ((c = *str++))
 202             hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
 203         return hash  % NR_BUCKETS;
 204 }
 205
 206 static struct hashtab *
 207 ehash_new(void)
 208 {
 209         struct hashtab *tab;
 210         if (!(tab = calloc(sizeof(struct hashtab), 1)))
 211                 return tab;
 212         tab->hashfunc = &hashfunc_pointer;
 213         tab->cmpfunc = &cmpfunc_pointer;
 214         return tab;
 215 }
 216
 217 /* returns 0 if equal */
 218 static
 219 int
 220 cmp_vals(evtr_variable_value_t a, evtr_variable_value_t b)
 221 {
 222         if (a->type != b->type)
 223                 return !0;
 224         switch (a->type) {
 225         case EVTR_VAL_NIL:
 226                 return 0;
 227         case EVTR_VAL_INT:
 228                 return !(a->num == b->num);
 229         case EVTR_VAL_STR:
 230                 return strcmp(a->str, b->str);
 231         case EVTR_VAL_HASH:
 232                 return !0;      /* come on! */
 233         case EVTR_VAL_CTOR:
 234                 err(3, "not implemented");
 235         }
 236         err(3, "can't get here");
 237 }
 238
 239 static
 240 uintptr_t
 241 cmpfunc_ctor(uintptr_t _a, uintptr_t _b)
 242 {
 243         evtr_variable_value_t vala, valb;
 244         vala = (evtr_variable_value_t)_a;
 245         valb = (evtr_variable_value_t)_b;
 246         if (strcmp(vala->ctor.name, valb->ctor.name))
 247                 return !0;
 248         vala = TAILQ_FIRST(&vala->ctor.args);
 249         valb = TAILQ_FIRST(&valb->ctor.args);
 250         for (;;) {
 251                 if (!vala && !valb)
 252                         return 0;
 253                 if ((vala && !valb) || (valb && !vala))
 254                         return !0;
 255                 if (cmp_vals(vala, valb))
 256                         return !0;
 257                 vala = TAILQ_NEXT(vala, link);
 258                 valb = TAILQ_NEXT(valb, link);
 259         }
 260 }
 261
 262 static
 263 uintptr_t
 264 hashfunc_ctor(uintptr_t _p)
 265 {
 266         evtr_variable_value_t val, ctor_val = (evtr_variable_value_t)_p;
 267         char buf[1024], *p = &buf[0];
 268         size_t len;
 269
 270         p = buf;
 271         assert(ctor_val->type == EVTR_VAL_CTOR);
 272         len = strlcpy(buf, ctor_val->ctor.name, sizeof(buf));
 273         if (len >= sizeof(buf))
 274                 goto done;
 275
 276         TAILQ_FOREACH(val, &ctor_val->ctor.args, link) {
 277                 switch (val->type) {
 278                 case EVTR_VAL_NIL:
 279                         assert(!"can't happen");
 280                         break;
 281                 case EVTR_VAL_INT:
 282                         len += snprintf(p + len, sizeof(buf) - len - 1,
 283                                         "%jd", val->num);
 284                         break;
 285                 case EVTR_VAL_STR:
 286                         len = strlcat(p, val->str, sizeof(buf));
 287                         break;
 288                 case EVTR_VAL_HASH:
 289                         break;  /* come on! */
 290                 case EVTR_VAL_CTOR:
 291                         err(3, "not implemented");
 292                 }
 293                 if (len >= (sizeof(buf) - 1))
 294                         break;
 295         }
 296 done:
 297         buf[sizeof(buf) - 1] = '\0';
 298         return hashfunc_string((uintptr_t)buf);
 299 }
 300
 301 typedef struct vector {
 302         uintmax_t *vals;
 303         int used;
 304         int allocated;
 305 } *vector_t;
 306
 307 static vector_t
 308 vector_new(void)
 309 {
 310         vector_t v;
 311         if (!(v = malloc(sizeof(*v))))
 312                 return v;
 313         v->allocated = 2;
 314         if (!(v->vals = malloc(v->allocated * sizeof(v->vals[0])))) {
 315                 free(v);
 316                 return NULL;
 317         }
 318         v->allocated =
 319         v->used = 0;
 320         return v;
 321 }
 322
 323 static
 324 void
 325 vector_push(vector_t v, uintmax_t val)
 326 {
 327         uintmax_t *tmp;
 328         if (v->used == v->allocated) {
 329                 tmp = realloc(v->vals, 2 * v->allocated * sizeof(v->vals[0]));
 330                 if (!tmp)
 331                         err(1, "out of memory");
 332                 v->vals = tmp;
 333                 v->allocated *= 2;
 334         }
 335         v->vals[v->used++] = val;
 336 }
 337
 338 static
 339 void
 340 vector_destroy(vector_t v)
 341 {
 342         free(v->vals);
 343         free(v);
 344 }
 345
 346 static
 347 int
 348 vector_nelems(vector_t v)
 349 {
 350         return v->used;
 351 }
 352
 353 #define vector_foreach(v, val, i)                                       \
 354         for (i = 0, val = v->vals[0]; i < v->used; val = v->vals[++i])
 355
 356 static
 357 double
 358 stddev(vector_t v, double avg)
 359 {
 360         uintmax_t val;
 361         int i;
 362         double diff, sqr_sum = 0.0;
 363
 364         if (vector_nelems(v) < 2)
 365                 return 1 / 0.0;
 366         vector_foreach(v, val, i) {
 367                 diff = val - avg;
 368                 sqr_sum += diff * diff;
 369         }
 370         return sqrt(sqr_sum / (vector_nelems(v) - 1));
 371 }
 372
 373 static
 374 void
 375 usage(void)
 376 {
 377         fprintf(stderr, "bad usage :P\n");
 378         exit(2);
 379 }
 380
 381 static
 382 void
 383 rows_init(struct rows *rows, int n, double height, double perc)
 384 {
 385         double row_h;
 386         rows->row_increment = height / n;
 387         /* actual row height */
 388         row_h = perc * rows->row_increment;
 389         rows->row_off = (rows->row_increment - row_h) / 2.0;
 390         assert(!isnan(rows->row_increment));
 391         assert(!isnan(rows->row_off));
 392 }
 393
 394 static
 395 void
 396 rows_n(struct rows *rows, int n, double *y, double *height)
 397 {
 398         *y = n * rows->row_increment + rows->row_off;
 399         *height = rows->row_increment - 2 * rows->row_off;
 400 }
 401
 402 /*
 403  * Which fontsize to use so that the string fits in the
 404  * given rect.
 405  */
 406 static
 407 double
 408 fontsize_for_rect(double width, double height, int textlen)
 409 {
 410         double wpc, maxh;
 411         /*
 412          * We start with a font size equal to the height
 413          * of the rectangle and round down so that we only
 414          * use a limited number of sizes.
 415          *
 416          * For a rectangle width comparable to the height,
 417          * the text might extend outside of the rectangle.
 418          * In that case we need to limit it.
 419          */
 420         /* available width per character */
 421         wpc = width / textlen;
 422         /*
 423          * Assuming a rough hight/width ratio for characters,
 424          * calculate the available height and round it down
 425          * just to be on the safe side.
 426          */
 427 #define GLYPH_HIGHT_TO_WIDTH 1.5
 428         maxh = GLYPH_HIGHT_TO_WIDTH * wpc * 0.9;
 429         if (height > maxh) {
 430                 height = maxh;
 431         } else if (height < 0.01) {
 432                 height = 0.01;
 433         } else {
 434                 /* rounding (XXX: make cheaper)*/
 435                 height = log(height);
 436                 height = round(height);
 437                 height = exp(height);
 438         }
 439         return height;
 440 }
 441
 442 struct pass_hook {
 443         void (*pre)(void *);
 444         void (*event)(void *, evtr_event_t);
 445         void (*post)(void *);
 446         void *data;
 447         struct evtr_filter *filts;
 448         int nfilts;
 449 };
 450
 451 struct thread_info {
 452         uint64_t runtime;
 453 };
 454
 455 struct ts_interval {
 456         uint64_t start;
 457         uint64_t end;
 458 };
 459
 460 struct td_switch_ctx {
 461         svg_document_t svg;
 462         struct rows *cpu_rows;
 463         struct rows *thread_rows;
 464         /* which events the user cares about */
 465         struct ts_interval interval;
 466         /* first/last event timestamps on any cpu */
 467         struct ts_interval firstlast;
 468         double width;
 469         double xscale;  /* scale factor applied to x */
 470         svg_rect_t cpu_sw_rect;
 471         svg_rect_t thread_rect;
 472         svg_rect_t inactive_rect;
 473         svg_text_t thread_label;
 474         struct cpu_table {
 475                 struct cpu *cpus;
 476                 int ncpus;
 477         } cputab;
 478         struct evtr_thread **top_threads;
 479         int nr_top_threads;
 480         double thread_rows_yoff;
 481 };
 482
 483 struct cpu {
 484         struct evtr_thread *td;
 485         int i;          /* cpu index */
 486         uint64_t ts;    /* time cpu switched to td */
 487         /* timestamp for first/last event on this cpu */
 488         struct ts_interval firstlast;
 489         double freq;
 490         uintmax_t evcnt;
 491 };
 492
 493 static
 494 void
 495 do_pass(struct pass_hook *hooks, int nhooks)
 496 {
 497         struct evtr_filter *filts = NULL;
 498         int nfilts = 0, i;
 499         struct evtr_query *q;
 500         struct evtr_event ev;
 501
 502         for (i = 0; i < nhooks; ++i) {
 503                 struct pass_hook *h = &hooks[i];
 504                 if (h->pre)
 505                         h->pre(h->data);
 506                 if (h->nfilts > 0) {
 507                         filts = realloc(filts, (nfilts + h->nfilts) *
 508                                         sizeof(struct evtr_filter));
 509                         if (!filts)
 510                                 err(1, "Out of memory");
 511                         memcpy(filts + nfilts, h->filts,
 512                                h->nfilts * sizeof(struct evtr_filter));
 513                         nfilts += h->nfilts;
 514                 }
 515         }
 516         q = evtr_query_init(evtr, filts, nfilts);
 517         if (!q)
 518                 err(1, "Can't initialize query\n");
 519         while(!evtr_query_next(q, &ev)) {
 520                 for (i = 0; i < nhooks; ++i) {
 521                         if (hooks[i].event)
 522                                 hooks[i].event(hooks[i].data, &ev);
 523                 }
 524         }
 525         if (evtr_query_error(q)) {
 526                 err(1, evtr_query_errmsg(q));
 527         }
 528         evtr_query_destroy(q);
 529
 530         for (i = 0; i < nhooks; ++i) {
 531                 if (hooks[i].post)
 532                         hooks[i].post(hooks[i].data);
 533         }
 534         if (evtr_rewind(evtr))
 535                 err(1, "Can't rewind event stream\n");
 536 }
 537
 538 static
 539 void
 540 draw_thread_run(struct td_switch_ctx *ctx, struct cpu *c, evtr_event_t ev, int row)
 541 {
 542         double x, w, y, height;
 543         w = (ev->ts - c->ts) * ctx->xscale;
 544         x = (ev->ts - ctx->firstlast.start) * ctx->xscale;
 545         rows_n(ctx->thread_rows, row, &y, &height);
 546         svg_rect_draw(ctx->svg, ctx->thread_rect, x - w,
 547                       y + ctx->thread_rows_yoff, w, height);
 548 }
 549
 550 static
 551 void
 552 draw_ctx_switch(struct td_switch_ctx *ctx, struct cpu *c, evtr_event_t ev)
 553 {
 554         struct svg_transform textrot;
 555         char comm[100];
 556         double x, w, fs, y, height;
 557         int textlen;
 558
 559         assert(ctx->xscale > 0.0);
 560         if (!c->ts)
 561                 return;
 562         /* distance to previous context switch */
 563         w = (ev->ts - c->ts) * ctx->xscale;
 564         x = (ev->ts - ctx->firstlast.start) * ctx->xscale;
 565         if ((x - w) < 0) {
 566                 fprintf(stderr, "(%ju - %ju) * %.20lf\n",
 567                         (uintmax_t)ev->ts,
 568                         (uintmax_t)ctx->firstlast.start, ctx->xscale);
 569                 abort();
 570         }
 571
 572         rows_n(ctx->cpu_rows, c->i, &y, &height);
 573         assert(!isnan(y));
 574         assert(!isnan(height));
 575
 576         svg_rect_draw(ctx->svg, ctx->cpu_sw_rect, x - w, y, w, height);
 577
 578         /*
 579          * Draw the text label describing the thread we
 580          * switched out of.
 581          */
 582         textrot.tx = x - w;
 583         textrot.ty = y;
 584         textrot.sx = 1.0;
 585         textrot.sy = 1.0;
 586         textrot.rot = 90.0;
 587         textlen = snprintf(comm, sizeof(comm) - 1, "%s (%p)",
 588                            c->td ? c->td->comm : "unknown",
 589                                  c->td ? c->td->id: NULL);
 590         if (textlen > (int)sizeof(comm))
 591                 textlen = sizeof(comm) - 1;
 592         comm[sizeof(comm) - 1] = '\0';
 593         /*
 594          * Note the width and hight are exchanged because
 595          * the bounding rectangle is rotated by 90 degrees.
 596          */
 597         fs = fontsize_for_rect(height, w, textlen);
 598         svg_text_draw(ctx->svg, ctx->thread_label, &textrot, comm,
 599                       fs);
 600 }
 601
 602
 603 /*
 604  * The stats for ntd have changed, update ->top_threads
 605  */
 606 static
 607 void
 608 top_threads_update(struct td_switch_ctx *ctx, struct evtr_thread *ntd)
 609 {
 610         struct thread_info *tdi = ntd->userdata;
 611         int i, j;
 612         for (i = 0; i < ctx->nr_top_threads; ++i) {
 613                 struct evtr_thread *td = ctx->top_threads[i];
 614                 if (td == ntd) {
 615                         /*
 616                          * ntd is already in top_threads and it is at
 617                          * the correct ranking
 618                          */
 619                         break;
 620                 }
 621                 if (!td) {
 622                         /* empty slot -- just insert our thread */
 623                         ctx->top_threads[i] = ntd;
 624                         break;
 625                 }
 626                 if (((struct thread_info *)td->userdata)->runtime >=
 627                     tdi->runtime) {
 628                         /* this thread ranks higher than we do. Move on */
 629                         continue;
 630                 }
 631                 /*
 632                  * OK, we've found the first thread that we outrank, so we
 633                  * need to replace it w/ our thread.
 634                  */
 635                 td = ntd;       /* td holds the thread we will insert next */
 636                 for (j = i + 1; j < ctx->nr_top_threads; ++j, ++i) {
 637                         struct evtr_thread *tmp;
 638
 639                         /* tmp holds the thread we replace */
 640                         tmp = ctx->top_threads[j];
 641                         ctx->top_threads[j] = td;
 642                         if (tmp == ntd) {
 643                                 /*
 644                                  * Our thread was already in the top list,
 645                                  * and we just removed the second instance.
 646                                  * Nothing more to do.
 647                                  */
 648                                 break;
 649                         }
 650                         td = tmp;
 651                 }
 652                 break;
 653         }
 654 }
 655
 656 static
 657 void
 658 ctxsw_prepare_event(void *_ctx, evtr_event_t ev)
 659 {
 660         struct td_switch_ctx *ctx = _ctx;
 661         struct cpu *c, *cpus = ctx->cputab.cpus;
 662         struct thread_info *tdi;
 663
 664         (void)evtr;
 665         printd(INTV, "test1 (%ju:%ju) : %ju\n",
 666                (uintmax_t)ctx->interval.start,
 667                (uintmax_t)ctx->interval.end,
 668                (uintmax_t)ev->ts);
 669         if ((ev->ts > ctx->interval.end) ||
 670             (ev->ts < ctx->interval.start))
 671                 return;
 672         printd(INTV, "PREPEV on %d\n", ev->cpu);
 673
 674         /* update first/last timestamps */
 675         c = &cpus[ev->cpu];
 676         if (!c->firstlast.start) {
 677                 c->firstlast.start = ev->ts;
 678         }
 679         c->firstlast.end = ev->ts;
 680         /*
 681          * c->td can be null when this is the first ctxsw event we
 682          * observe for a cpu
 683          */
 684         if (c->td) {
 685                 /* update thread stats */
 686                 if (!c->td->userdata) {
 687                         if (!(tdi = malloc(sizeof(struct thread_info))))
 688                                 err(1, "Out of memory");
 689                         c->td->userdata = tdi;
 690                         tdi->runtime = 0;
 691                 }
 692                 tdi = c->td->userdata;
 693                 tdi->runtime += ev->ts - c->ts;
 694                 top_threads_update(ctx, c->td);
 695         }
 696
 697         /* Notice that ev->td is the new thread for ctxsw events */
 698         c->td = ev->td;
 699         c->ts = ev->ts;
 700 }
 701
 702 static
 703 void
 704 find_first_last_ts(struct cpu_table *cputab, struct ts_interval *fl)
 705 {
 706         struct cpu *cpus = &cputab->cpus[0];
 707         int i;
 708
 709         fl->start = -1;
 710         fl->end = 0;
 711         for (i = 0; i < cputab->ncpus; ++i) {
 712                 printd(INTV, "cpu%d: (%ju, %ju)\n", i,
 713                        (uintmax_t)cpus[i].firstlast.start,
 714                        (uintmax_t)cpus[i].firstlast.end);
 715                 if (cpus[i].firstlast.start &&
 716                     (cpus[i].firstlast.start < fl->start))
 717                         fl->start = cpus[i].firstlast.start;
 718                 if (cpus[i].firstlast.end &&
 719                     (cpus[i].firstlast.end > fl->end))
 720                         fl->end = cpus[i].firstlast.end;
 721                 cpus[i].td = NULL;
 722                 cpus[i].ts = 0;
 723         }
 724         printd(INTV, "global (%jd, %jd)\n", (uintmax_t)fl->start, (uintmax_t)fl->end);
 725 }
 726
 727 static
 728 void
 729 ctxsw_prepare_post(void *_ctx)
 730 {
 731         struct td_switch_ctx *ctx = _ctx;
 732
 733         find_first_last_ts(&ctx->cputab, &ctx->firstlast);
 734 }
 735
 736 static
 737 void
 738 ctxsw_draw_pre(void *_ctx)
 739 {
 740         struct td_switch_ctx *ctx = _ctx;
 741         struct svg_transform textrot;
 742         char comm[100];
 743         double y, height, fs;
 744         int i, textlen;
 745         struct evtr_thread *td;
 746
 747         textrot.tx = 0.0 - 0.2; /* XXX */
 748         textrot.sx = 1.0;
 749         textrot.sy = 1.0;
 750         textrot.rot = 270.0;
 751
 752         for (i = 0; i < ctx->nr_top_threads; ++i) {
 753                 td = ctx->top_threads[i];
 754                 if (!td)
 755                         break;
 756                 rows_n(ctx->thread_rows, i, &y, &height);
 757                 svg_rect_draw(ctx->svg, ctx->inactive_rect, 0.0,
 758                               y + ctx->thread_rows_yoff, ctx->width, height);
 759                 textlen = snprintf(comm, sizeof(comm) - 1, "%s (%p)",
 760                                    td->comm, td->id);
 761                 if (textlen > (int)sizeof(comm))
 762                         textlen = sizeof(comm) - 1;
 763                 comm[sizeof(comm) - 1] = '\0';
 764                 fs = fontsize_for_rect(height, 100.0, textlen);
 765
 766                 textrot.ty = y + ctx->thread_rows_yoff + height;
 767                 svg_text_draw(ctx->svg, ctx->thread_label, &textrot,
 768                               comm, fs);
 769         }
 770 }
 771
 772 static
 773 void
 774 ctxsw_draw_event(void *_ctx, evtr_event_t ev)
 775 {
 776         struct td_switch_ctx *ctx = _ctx;
 777         struct cpu *c = &ctx->cputab.cpus[ev->cpu];
 778         int i;
 779
 780         /*
 781          * ctx->firstlast.end can be 0 if there were no events
 782          * in the specified interval, in which case
 783          * ctx->firstlast.start is invalid too.
 784          */
 785         assert(!ctx->firstlast.end || (ev->ts >= ctx->firstlast.start));
 786         printd(INTV, "test2 (%ju:%ju) : %ju\n", (uintmax_t)ctx->interval.start,
 787                (uintmax_t)ctx->interval.end, (uintmax_t)ev->ts);
 788         if ((ev->ts > ctx->interval.end) ||
 789             (ev->ts < ctx->interval.start))
 790                 return;
 791         printd(INTV, "DRAWEV %d\n", ev->cpu);
 792         if (c->td != ev->td) {  /* thread switch (or preemption) */
 793                 draw_ctx_switch(ctx, c, ev);
 794                 /* XXX: this is silly */
 795                 for (i = 0; i < ctx->nr_top_threads; ++i) {
 796                         if (!ctx->top_threads[i])
 797                                 break;
 798                         if (ctx->top_threads[i] == c->td) {
 799                                 draw_thread_run(ctx, c, ev, i);
 800                                 break;
 801                         }
 802                 }
 803                 c->td = ev->td;
 804                 c->ts = ev->ts;
 805         }
 806 }
 807
 808 static
 809 void
 810 cputab_init(struct cpu_table *ct)
 811 {
 812         struct cpu *cpus;
 813         double *freqs;
 814         int i;
 815
 816         if ((ct->ncpus = evtr_ncpus(evtr)) <= 0)
 817                 err(1, "No cpu information!\n");
 818         printd(MISC, "evtranalyze: ncpus %d\n", ct->ncpus);
 819         if (!(ct->cpus = malloc(sizeof(struct cpu) * ct->ncpus))) {
 820                 err(1, "Can't allocate memory\n");
 821         }
 822         cpus = ct->cpus;
 823         if (!(freqs = malloc(sizeof(double) * ct->ncpus))) {
 824                 err(1, "Can't allocate memory\n");
 825         }
 826         if ((i = evtr_cpufreqs(evtr, freqs))) {
 827                 warnc(i, "Can't get cpu frequencies\n");
 828                 for (i = 0; i < ct->ncpus; ++i) {
 829                         freqs[i] = -1.0;
 830                 }
 831         }
 832
 833         /* initialize cpu array */
 834         for (i = 0; i < ct->ncpus; ++i) {
 835                 cpus[i].td = NULL;
 836                 cpus[i].ts = 0;
 837                 cpus[i].i = i;
 838                 cpus[i].firstlast.start = 0;
 839                 cpus[i].firstlast.end = 0;
 840                 cpus[i].evcnt = 0;
 841                 cpus[i].freq = freqs[i];
 842         }
 843         free(freqs);
 844 }
 845
 846 static
 847 void
 848 parse_interval(const char *_str, struct ts_interval *ts,
 849                struct cpu_table *cputab)
 850 {
 851         double s, e, freq;
 852         const char *str = _str + 1;
 853
 854         if ('c' == *_str) {     /* cycles */
 855                 if (sscanf(str, "%" SCNu64 ":%" SCNu64,
 856                            &ts->start,
 857                            &ts->end) == 2)
 858                         return;
 859         } else if ('m' == *_str) {      /* miliseconds */
 860                 if (sscanf(str, "%lf:%lf", &s, &e) == 2) {
 861                         freq = cputab->cpus[0].freq;
 862                         freq *= 1000.0; /* msecs */
 863                         if (freq < 0.0) {
 864                                 fprintf(stderr, "No frequency information"
 865                                         " available\n");
 866                                 err(2, "Can't convert time to cycles\n");
 867                         }
 868                         ts->start = s * freq;
 869                         ts->end = e * freq;
 870                         return;
 871                 }
 872         }
 873         fprintf(stderr, "invalid interval format: %s\n", _str);
 874         usage();
 875 }
 876
 877
 878 static
 879 int
 880 cmd_svg(int argc, char **argv)
 881 {
 882         svg_document_t svg;
 883         int ch;
 884         double height, width;
 885         struct rows cpu_rows, thread_rows;
 886         struct td_switch_ctx td_ctx;
 887         const char *outpath = "output.svg";
 888         struct evtr_filter ctxsw_filts[2] = {
 889                 {
 890                         .flags = 0,
 891                         .cpu = -1,
 892                         .ev_type = EVTR_TYPE_PROBE,
 893                 },
 894                 {
 895                         .flags = 0,
 896                         .cpu = -1,
 897                         .ev_type = EVTR_TYPE_PROBE,
 898                 },
 899         };
 900         struct pass_hook ctxsw_prepare = {
 901                 .pre = NULL,
 902                 .event = ctxsw_prepare_event,
 903                 .post = ctxsw_prepare_post,
 904                 .data = &td_ctx,
 905                 .filts = ctxsw_filts,
 906                 .nfilts = sizeof(ctxsw_filts)/sizeof(ctxsw_filts[0]),
 907         }, ctxsw_draw = {
 908                 .pre = ctxsw_draw_pre,
 909                 .event = ctxsw_draw_event,
 910                 .post = NULL,
 911                 .data = &td_ctx,
 912                 .filts = ctxsw_filts,
 913                 .nfilts = sizeof(ctxsw_filts)/sizeof(ctxsw_filts[0]),
 914         };
 915
 916         /*
 917          * We are interested in thread switch and preemption
 918          * events, but we don't use the data directly. Instead
 919          * we rely on ev->td.
 920          */
 921         ctxsw_filts[0].fmt = "sw  %p > %p";
 922         ctxsw_filts[1].fmt = "pre %p > %p";
 923         td_ctx.interval.start = 0;
 924         td_ctx.interval.end = -1;       /* i.e. no interval given */
 925         td_ctx.nr_top_threads = NR_TOP_THREADS;
 926         cputab_init(&td_ctx.cputab);    /* needed for parse_interval() */
 927
 928         optind = 0;
 929         optreset = 1;
 930         while ((ch = getopt(argc, argv, "i:o:")) != -1) {
 931                 switch (ch) {
 932                 case 'i':
 933                         parse_interval(optarg, &td_ctx.interval,
 934                                        &td_ctx.cputab);
 935                         break;
 936                 case 'o':
 937                         outpath = optarg;
 938                         break;
 939                 default:
 940                         usage();
 941                 }
 942
 943         }
 944         argc -= optind;
 945         argv += optind;
 946
 947         height = 200.0;
 948         width = 700.0;
 949         td_ctx.width = width;
 950
 951         if (!(td_ctx.top_threads = calloc(td_ctx.nr_top_threads,
 952                                           sizeof(struct evtr_thread *))))
 953                 err(1, "Can't allocate memory\n");
 954         if (!(svg = svg_document_create(outpath)))
 955                 err(1, "Can't open svg document\n");
 956
 957         /*
 958          * Create rectangles to use for output.
 959          */
 960         if (!(td_ctx.cpu_sw_rect = svg_rect_new("generic")))
 961                 err(1, "Can't create rectangle\n");
 962         if (!(td_ctx.thread_rect = svg_rect_new("thread")))
 963                 err(1, "Can't create rectangle\n");
 964         if (!(td_ctx.inactive_rect = svg_rect_new("inactive")))
 965                 err(1, "Can't create rectangle\n");
 966         /* text for thread names */
 967         if (!(td_ctx.thread_label = svg_text_new("generic")))
 968                 err(1, "Can't create text\n");
 969         rows_init(&cpu_rows, td_ctx.cputab.ncpus, height, 0.9);
 970         td_ctx.svg = svg;
 971         td_ctx.xscale = -1.0;
 972         td_ctx.cpu_rows = &cpu_rows;
 973
 974         do_pass(&ctxsw_prepare, 1);
 975         td_ctx.thread_rows_yoff = height;
 976         td_ctx.thread_rows = &thread_rows;
 977         rows_init(td_ctx.thread_rows, td_ctx.nr_top_threads, 300, 0.9);
 978         td_ctx.xscale = width / (td_ctx.firstlast.end - td_ctx.firstlast.start);
 979         printd(SVG, "first %ju, last %ju, xscale %lf\n",
 980                (uintmax_t)td_ctx.firstlast.start, (uintmax_t)td_ctx.firstlast.end,
 981                td_ctx.xscale);
 982
 983         do_pass(&ctxsw_draw, 1);
 984
 985         svg_document_close(svg);
 986         return 0;
 987 }
 988
 989 static
 990 int
 991 cmd_show(int argc, char **argv)
 992 {
 993         struct evtr_event ev;
 994         struct evtr_query *q;
 995         struct evtr_filter filt;
 996         struct cpu_table cputab;
 997         double freq;
 998         int ch;
 999         uint64_t last_ts = 0;
1000
1001         cputab_init(&cputab);
1002         /*
1003          * Assume all cores run on the same frequency
1004          * for now. There's no reason to complicate
1005          * things unless we can detect frequency change
1006          * events as well.
1007          *
1008          * Note that the code is very simplistic and will
1009          * produce garbage if the kernel doesn't fixup
1010          * the timestamps for cores running with different
1011          * frequencies.
1012          */
1013         freq = cputab.cpus[0].freq;
1014         freq /= 1000000;        /* we want to print out usecs */
1015         printd(MISC, "using freq = %lf\n", freq);
1016         filt.flags = 0;
1017         filt.cpu = -1;
1018         filt.ev_type = EVTR_TYPE_PROBE;
1019         filt.fmt = NULL;
1020         optind = 0;
1021         optreset = 1;
1022         while ((ch = getopt(argc, argv, "f:")) != -1) {
1023                 switch (ch) {
1024                 case 'f':
1025                         filt.fmt = optarg;
1026                         break;
1027                 }
1028         }
1029         q = evtr_query_init(evtr, &filt, 1);
1030         if (!q)
1031                 err(1, "Can't initialize query\n");
1032         while(!evtr_query_next(q, &ev)) {
1033                 char buf[1024];
1034
1035                 if (!last_ts)
1036                         last_ts = ev.ts;
1037                 if (freq < 0.0) {
1038                         printf("%s\t%ju cycles\t[%.3d]\t%s:%d",
1039                                ev.td ? ev.td->comm : "unknown",
1040                                (uintmax_t)(ev.ts - last_ts), ev.cpu,
1041                                basename(ev.file), ev.line);
1042                 } else {
1043                         printf("%s\t%.3lf usecs\t[%.3d]\t%s:%d",
1044                                ev.td ? ev.td->comm : "unknown",
1045                                (ev.ts - last_ts) / freq, ev.cpu,
1046                                basename(ev.file), ev.line);
1047                 }
1048                 if (ev.fmt) {
1049                         evtr_event_data(&ev, buf, sizeof(buf));
1050                         printf(" !\t%s\n", buf);
1051                 } else {
1052                         printf("\n");
1053                 }
1054                 last_ts = ev.ts;
1055         }
1056         if (evtr_query_error(q)) {
1057                 err(1, evtr_query_errmsg(q));
1058         }
1059         evtr_query_destroy(q);
1060         return 0;
1061 }
1062
1063 struct stats_ops {
1064         const char *statscmd;
1065         void *(*prepare)(int, char **, struct evtr_filter *);
1066         void (*each_event)(void *, evtr_event_t);
1067         void (*report)(void *);
1068 };
1069
1070 struct stats_integer_ctx {
1071         const char *varname;
1072         struct {
1073                 int plot;
1074                 const char *path;
1075         } opts;
1076         void *plotter_ctx;
1077         struct plotter *plotter;
1078         plotid_t time_plot;
1079         uintmax_t sum;
1080         uintmax_t occurences;
1081 };
1082
1083 static
1084 void *
1085 stats_integer_prepare(int argc, char **argv, struct evtr_filter *filt)
1086 {
1087         struct stats_integer_ctx *ctx;
1088         int ch;
1089
1090         if (!(ctx = calloc(1, sizeof(*ctx))))
1091                 return ctx;
1092
1093         optind = 0;
1094         optreset = 1;
1095         while ((ch = getopt(argc, argv, "p:")) != -1) {
1096                 switch (ch) {
1097                 case 'p':
1098                         ctx->opts.plot = !0;
1099                         ctx->opts.path = optarg;
1100                         break;
1101                 default:
1102                         usage();
1103                 }
1104         }
1105         argc -= optind;
1106         argv += optind;
1107
1108         if (argc != 1)
1109                 err(2, "Need exactly one variable");
1110         ctx->varname = argv[0];
1111         ctx->sum = ctx->occurences = 0;
1112         filt->flags = 0;
1113         filt->cpu = -1;
1114         filt->ev_type = EVTR_TYPE_STMT;
1115         filt->var = ctx->varname;
1116         if (!ctx->opts.plot)
1117                 return ctx;
1118
1119         if (!(ctx->plotter = plotter_factory()))
1120                 err(1, "can't allocate plotter");
1121         if (!(ctx->plotter_ctx = ctx->plotter->plot_init(ctx->opts.path)))
1122                 err(1, "can't allocate plotter context");
1123
1124         if ((ctx->time_plot = ctx->plotter->plot_new(ctx->plotter_ctx,
1125                                                           PLOT_TYPE_LINE,
1126                                                           ctx->varname)) < 0)
1127                 err(1, "can't create histogram");
1128         return ctx;
1129 }
1130
1131 static
1132 void
1133 stats_integer_each(void *_ctx, evtr_event_t ev)
1134 {
1135         struct stats_integer_ctx *ctx = _ctx;
1136         if (EVTR_VAL_INT != ev->stmt.val->type) {
1137                 fprintf(stderr, "event at %jd (cpu %d) does not treat %s as an"
1138                         "integer variable; ignored\n", ev->ts, ev->cpu,
1139                         ctx->varname);
1140                 return;
1141         }
1142         if (ctx->plotter)
1143                 ctx->plotter->plot_line(ctx->plotter_ctx, ctx->time_plot,
1144                                         (double)ev->ts, (double)ev->stmt.val->num);
1145         ctx->sum += ev->stmt.val->num;
1146         ++ctx->occurences;
1147 }
1148
1149 static
1150 void
1151 stats_integer_report(void *_ctx)
1152 {
1153         struct stats_integer_ctx *ctx = _ctx;
1154         printf("median for variable %s is %lf\n", ctx->varname,
1155                (double)ctx->sum / ctx->occurences);
1156         if (ctx->plotter)
1157                 ctx->plotter->plot_finish(ctx->plotter_ctx);
1158
1159         free(ctx);
1160 }
1161
1162 struct stats_completion_ctx {
1163         struct stats_completion_options {
1164                 int plot;
1165                 const char *path;
1166         } opts;
1167         struct plotter *plotter;
1168         void *plotter_ctx;
1169         plotid_t durations_plot;
1170         const char *varname;
1171         const char *ctor;
1172         const char *dtor;
1173         struct hashtab *ctors;
1174         uintmax_t historical_dtors;
1175         uintmax_t uncompleted_events;
1176         uintmax_t begun_events;
1177         uintmax_t completed_events;
1178         uintmax_t completed_duration_sum;
1179         vector_t durations;
1180 };
1181
1182 struct ctor_data {
1183         evtr_variable_value_t val;
1184         uintmax_t ts;
1185 };
1186
1187 static
1188 struct ctor_data *
1189 ctor_data_new(evtr_event_t ev)
1190 {
1191         struct ctor_data *cd;
1192
1193         if (!(cd = malloc(sizeof(*cd))))
1194                 return cd;
1195         cd->val = ev->stmt.val;
1196         cd->ts = ev->ts;
1197         return cd;
1198 }
1199
1200 static
1201 void *
1202 stats_completion_prepare(int argc, char **argv, struct evtr_filter *filt)
1203 {
1204         struct stats_completion_ctx *ctx;
1205         int ch;
1206
1207         if (!(ctx = calloc(1, sizeof(*ctx))))
1208                 return ctx;
1209
1210         optind = 0;
1211         optreset = 1;
1212         while ((ch = getopt(argc, argv, "p:")) != -1) {
1213                 switch (ch) {
1214                 case 'p':
1215                         ctx->opts.plot = !0;
1216                         ctx->opts.path = optarg;
1217                         break;
1218                 default:
1219                         usage();
1220                 }
1221         }
1222         argc -= optind;
1223         argv += optind;
1224         if (argc != 3)
1225                 err(2, "need a variable, a constructor and a destructor");
1226         if (!(ctx->ctors = ehash_new()))
1227                 goto free_ctx;
1228         ctx->ctors->hashfunc = &hashfunc_ctor;
1229         ctx->ctors->cmpfunc = &cmpfunc_ctor;
1230         if (!(ctx->durations = vector_new()))
1231                 goto free_ctors;
1232         ctx->varname = argv[0];
1233         ctx->ctor = argv[1];
1234         ctx->dtor = argv[2];
1235
1236         filt->flags = 0;
1237         filt->cpu = -1;
1238         filt->ev_type = EVTR_TYPE_STMT;
1239         filt->var = ctx->varname;
1240
1241         if (!ctx->opts.plot)
1242                 return ctx;
1243
1244         if (!(ctx->plotter = plotter_factory()))
1245                 err(1, "can't allocate plotter");
1246         if (!(ctx->plotter_ctx = ctx->plotter->plot_init(ctx->opts.path)))
1247                 err(1, "can't allocate plotter context");
1248
1249         if ((ctx->durations_plot = ctx->plotter->plot_new(ctx->plotter_ctx,
1250                                                           PLOT_TYPE_HIST,
1251                                                           ctx->varname)) < 0)
1252                 err(1, "can't create histogram");
1253         return ctx;
1254 free_ctors:
1255         ;       /* XXX */
1256 free_ctx:
1257         free(ctx);
1258         return NULL;
1259 }
1260
1261 static
1262 void
1263 stats_completion_each(void *_ctx, evtr_event_t ev)
1264 {
1265         struct stats_completion_ctx *ctx = _ctx;
1266         struct ctor_data *cd;
1267
1268         if (ev->stmt.val->type != EVTR_VAL_CTOR) {
1269                 fprintf(stderr, "event at %jd (cpu %d) does not assign to %s "
1270                         "with a data constructor; ignored\n", ev->ts, ev->cpu,
1271                         ctx->varname);
1272                 return;
1273         }
1274         if (!strcmp(ev->stmt.val->ctor.name, ctx->ctor)) {
1275                 uintptr_t v;
1276                 if (!ehash_find(ctx->ctors, (uintptr_t)ev->stmt.val, &v)) {
1277                         /* XXX:better diagnostic */
1278                         fprintf(stderr, "duplicate ctor\n");
1279                         err(3, "giving up");
1280                 }
1281                 if (!(cd = ctor_data_new(ev)))
1282                         err(1, "out of memory");
1283                 v = (uintptr_t)cd;
1284                 if (!ehash_insert(ctx->ctors, (uintptr_t)ev->stmt.val, v))
1285                         err(1, "out of memory");
1286                 ++ctx->begun_events;
1287         } else if (!strcmp(ev->stmt.val->ctor.name, ctx->dtor)) {
1288                 uintptr_t v;
1289                 const char *tmp = ev->stmt.val->ctor.name;
1290                 ev->stmt.val->ctor.name = ctx->ctor;
1291                 if (ehash_find(ctx->ctors, (uintptr_t)ev->stmt.val, &v)) {
1292                         ++ctx->historical_dtors;
1293                         ev->stmt.val->ctor.name = tmp;
1294                         return;
1295                 }
1296                 cd = (struct ctor_data *)v;
1297                 if (cd->ts >= ev->ts) {
1298                         /* XXX:better diagnostic */
1299                         fprintf(stderr, "destructor preceds constructor;"
1300                                 " ignored\n");
1301                         ev->stmt.val->ctor.name = tmp;
1302                         return;
1303                 }
1304                 if (ctx->plotter)
1305                         ctx->plotter->plot_histogram(ctx->plotter_ctx,
1306                                                      ctx->durations_plot,
1307                                                      (double)(ev->ts - cd->ts));
1308                 vector_push(ctx->durations, ev->ts - cd->ts);
1309                 ++ctx->completed_events;
1310                 ctx->completed_duration_sum += ev->ts - cd->ts;
1311                 if (ehash_delete(ctx->ctors, (uintptr_t)ev->stmt.val))
1312                         err(3, "ctor disappeared from hash!");
1313                 ev->stmt.val->ctor.name = tmp;
1314         } else {
1315                 fprintf(stderr, "event at %jd (cpu %d) assigns to %s "
1316                         "with an unexpected data constructor; ignored\n",
1317                         ev->ts, ev->cpu, ctx->varname);
1318                 return;
1319         }
1320 }
1321
1322 static
1323 void
1324 stats_completion_report(void *_ctx)
1325 {
1326         struct stats_completion_ctx *ctx = _ctx;
1327         double avg;
1328
1329         printf("Events completed without having started:\t%jd\n",
1330                ctx->historical_dtors);
1331         printf("Events started but didn't complete:\t%jd\n",
1332                ctx->begun_events - ctx->completed_events);
1333         avg = (double)ctx->completed_duration_sum / ctx->completed_events;
1334         printf("Average event duration:\t%lf (stddev %lf)\n", avg,
1335                stddev(ctx->durations, avg));
1336
1337         if (ctx->plotter)
1338                 ctx->plotter->plot_finish(ctx->plotter_ctx);
1339         vector_destroy(ctx->durations);
1340         /* XXX: hash */
1341         free(ctx);
1342 }
1343
1344 static struct stats_ops cmd_stat_ops[] = {
1345         {
1346                 .statscmd = "integer",
1347                 .prepare = &stats_integer_prepare,
1348                 .each_event = &stats_integer_each,
1349                 .report = &stats_integer_report,
1350         },
1351         {
1352                 .statscmd = "completion",
1353                 .prepare = &stats_completion_prepare,
1354                 .each_event = &stats_completion_each,
1355                 .report = &stats_completion_report,
1356         },
1357         {
1358                 .statscmd = NULL,
1359         },
1360 };
1361
1362 static
1363 int
1364 cmd_stats(int argc, char **argv)
1365 {
1366         struct evtr_event ev;
1367         struct evtr_query *q;
1368         struct evtr_filter filt;
1369         struct cpu_table cputab;
1370         double freq;
1371         uint64_t last_ts = 0;
1372         struct stats_ops *statsops = &cmd_stat_ops[0];
1373         void *statctx;
1374
1375         for (; statsops->statscmd; ++statsops) {
1376                 if (!strcmp(statsops->statscmd, argv[1]))
1377                         break;
1378         }
1379         if (!statsops->statscmd)
1380                 err(2, "No such stats type: %s", argv[1]);
1381
1382         --argc;
1383         ++argv;
1384         cputab_init(&cputab);
1385         /*
1386          * Assume all cores run on the same frequency
1387          * for now. There's no reason to complicate
1388          * things unless we can detect frequency change
1389          * events as well.
1390          *
1391          * Note that the code is very simplistic and will
1392          * produce garbage if the kernel doesn't fixup
1393          * the timestamps for cores running with different
1394          * frequencies.
1395          */
1396         freq = cputab.cpus[0].freq;
1397         freq /= 1000000;        /* we want to print out usecs */
1398         printd(MISC, "using freq = %lf\n", freq);
1399
1400         if (!(statctx = statsops->prepare(argc, argv, &filt)))
1401                 err(1, "Can't allocate stats context");
1402         q = evtr_query_init(evtr, &filt, 1);
1403         if (!q)
1404                 err(1, "Can't initialize query");
1405         while(!evtr_query_next(q, &ev)) {
1406
1407                 if (!last_ts)
1408                         last_ts = ev.ts;
1409
1410                 assert(ev.type == EVTR_TYPE_STMT);
1411                 statsops->each_event(statctx, &ev);
1412                 last_ts = ev.ts;
1413         }
1414         if (evtr_query_error(q)) {
1415                 err(1, evtr_query_errmsg(q));
1416         }
1417         evtr_query_destroy(q);
1418         statsops->report(statctx);
1419         return 0;
1420 }
1421
1422
1423 static
1424 int
1425 cmd_summary(int argc, char **argv)
1426 {
1427         struct evtr_filter filt;
1428         struct evtr_event ev;
1429         struct evtr_query *q;
1430         double freq;
1431         struct cpu_table cputab;
1432         struct ts_interval global;
1433         uintmax_t global_evcnt;
1434         int i;
1435
1436         (void)argc;
1437         (void)argv;
1438
1439         cputab_init(&cputab);
1440         filt.ev_type = EVTR_TYPE_PROBE;
1441         filt.fmt = NULL;
1442         filt.flags = 0;
1443         filt.cpu = -1;
1444
1445         q = evtr_query_init(evtr, &filt, 1);
1446         if (!q)
1447                 err(1, "Can't initialize query\n");
1448         while(!evtr_query_next(q, &ev)) {
1449                 struct cpu *c = &cputab.cpus[ev.cpu];
1450                 if (!c->firstlast.start)
1451                         c->firstlast.start = ev.ts;
1452                 ++c->evcnt;
1453                 c->firstlast.end = ev.ts;
1454         }
1455         if (evtr_query_error(q)) {
1456                 err(1, evtr_query_errmsg(q));
1457         }
1458         evtr_query_destroy(q);
1459
1460         find_first_last_ts(&cputab, &global);
1461
1462         freq = cputab.cpus[0].freq;
1463         global_evcnt = 0;
1464         for (i = 0; i < cputab.ncpus; ++i) {
1465                 struct cpu *c = &cputab.cpus[i];
1466                 printf("CPU %d: %jd events in %.3lf secs\n", i,
1467                        c->evcnt, (c->firstlast.end - c->firstlast.start)
1468                        / freq);
1469                 global_evcnt += c->evcnt;
1470         }
1471         printf("Total: %jd events on %d cpus in %.3lf secs\n", global_evcnt,
1472                cputab.ncpus, (global.end - global.start) / freq);
1473         return 0;
1474 }
1475
1476
1477 int
1478 main(int argc, char **argv)
1479 {
1480         int ch;
1481         FILE *inf;
1482         struct command *cmd;
1483         char *tmp;
1484
1485         while ((ch = getopt(argc, argv, "f:D:")) != -1) {
1486                 switch (ch) {
1487                 case 'f':
1488                         opt_infile = optarg;
1489                         break;
1490                 case 'D':
1491                         if ((tmp = strchr(optarg, ':'))) {
1492                                 *tmp++ = '\0';
1493                                 evtr_set_debug(tmp);
1494                         }
1495                         printd_set_flags(optarg, &evtranalyze_debug);
1496                         break;
1497                 default:
1498                         usage();
1499                 }
1500         }
1501         argc -= optind;
1502         argv += optind;
1503
1504         if (argc == 0) {
1505                 err(2, "need to specify a command\n");
1506         }
1507         if (!opt_infile) {
1508                 err(2, "you need to specify an input file\n");
1509         } else if (!strcmp(opt_infile, "-")) {
1510                 inf = stdin;
1511         } else {
1512                 inf = fopen(opt_infile, "r");
1513                 if (!inf) {
1514                         err(2, "Can't open input file\n");
1515                 }
1516         }
1517
1518         if (!(evtr = evtr_open_read(inf))) {
1519                 err(1, "Can't open evtr stream\n");
1520         }
1521
1522
1523         for (cmd = commands; cmd->name != NULL; ++cmd) {
1524                 if (strcmp(argv[0], cmd->name))
1525                         continue;
1526                 cmd->func(argc, argv);
1527                 break;
1528         }
1529         if (!cmd->name) {
1530                 err(2, "no such command: %s\n", argv[0]);
1531         }
1532
1533         evtr_close(evtr);
1534         return 0;
1535 }