gprof/hist.c

   1 /*
   2  * Histogram related operations.
   3  */
   4 #include <stdio.h>
   5 #include "libiberty.h"
   6 #include "gprof.h"
   7 #include "corefile.h"
   8 #include "gmon_io.h"
   9 #include "gmon_out.h"
  10 #include "hist.h"
  11 #include "symtab.h"
  12 #include "sym_ids.h"
  13 #include "utils.h"
  14
  15 #define UNITS_TO_CODE (offset_to_code / sizeof(UNIT))
  16
  17 static void scale_and_align_entries PARAMS ((void));
  18
  19 /* declarations of automatically generated functions to output blurbs: */
  20 extern void flat_blurb PARAMS ((FILE * fp));
  21
  22 bfd_vma s_lowpc;                /* lowest address in .text */
  23 bfd_vma s_highpc = 0;           /* highest address in .text */
  24 bfd_vma lowpc, highpc;          /* same, but expressed in UNITs */
  25 int hist_num_bins = 0;          /* number of histogram samples */
  26 int *hist_sample = 0;           /* histogram samples (shorts in the file!) */
  27 double hist_scale;
  28 char hist_dimension[sizeof (((struct gmon_hist_hdr *) 0)->dimen) + 1] =
  29   "seconds";
  30 char hist_dimension_abbrev = 's';
  31
  32 static double accum_time;       /* accumulated time so far for print_line() */
  33 static double total_time;       /* total time for all routines */
  34 /*
  35  * Table of SI prefixes for powers of 10 (used to automatically
  36  * scale some of the values in the flat profile).
  37  */
  38 const struct
  39   {
  40     char prefix;
  41     double scale;
  42   }
  43 SItab[] =
  44 {
  45   {
  46     'T', 1e-12
  47   }
  48   ,                             /* tera */
  49   {
  50     'G', 1e-09
  51   }
  52   ,                             /* giga */
  53   {
  54     'M', 1e-06
  55   }
  56   ,                             /* mega */
  57   {
  58     'K', 1e-03
  59   }
  60   ,                             /* kilo */
  61   {
  62     ' ', 1e-00
  63   }
  64   ,
  65   {
  66     'm', 1e+03
  67   }
  68   ,                             /* milli */
  69   {
  70     'u', 1e+06
  71   }
  72   ,                             /* micro */
  73   {
  74     'n', 1e+09
  75   }
  76   ,                             /* nano */
  77   {
  78     'p', 1e+12
  79   }
  80   ,                             /* pico */
  81   {
  82     'f', 1e+15
  83   }
  84   ,                             /* femto */
  85   {
  86     'a', 1e+18
  87   }
  88   ,                             /* ato */
  89 };
  90
  91 /*
  92  * Read the histogram from file IFP.  FILENAME is the name of IFP and
  93  * is provided for formatting error messages only.
  94  */
  95 void
  96 DEFUN (hist_read_rec, (ifp, filename), FILE * ifp AND const char *filename)
  97 {
  98   struct gmon_hist_hdr hdr;
  99   bfd_vma n_lowpc, n_highpc;
 100   int i, ncnt, profrate;
 101   UNIT count;
 102
 103   if (fread (&hdr, sizeof (hdr), 1, ifp) != 1)
 104     {
 105       fprintf (stderr, _("%s: %s: unexpected end of file\n"),
 106                whoami, filename);
 107       done (1);
 108     }
 109
 110   n_lowpc = (bfd_vma) get_vma (core_bfd, (bfd_byte *) hdr.low_pc);
 111   n_highpc = (bfd_vma) get_vma (core_bfd, (bfd_byte *) hdr.high_pc);
 112   ncnt = bfd_get_32 (core_bfd, (bfd_byte *) hdr.hist_size);
 113   profrate = bfd_get_32 (core_bfd, (bfd_byte *) hdr.prof_rate);
 114   strncpy (hist_dimension, hdr.dimen, sizeof (hdr.dimen));
 115   hist_dimension[sizeof (hdr.dimen)] = '\0';
 116   hist_dimension_abbrev = hdr.dimen_abbrev;
 117
 118   if (!s_highpc)
 119     {
 120
 121       /* this is the first histogram record: */
 122
 123       s_lowpc = n_lowpc;
 124       s_highpc = n_highpc;
 125       lowpc = (bfd_vma) n_lowpc / sizeof (UNIT);
 126       highpc = (bfd_vma) n_highpc / sizeof (UNIT);
 127       hist_num_bins = ncnt;
 128       hz = profrate;
 129     }
 130
 131   DBG (SAMPLEDEBUG,
 132        printf ("[hist_read_rec] n_lowpc 0x%lx n_highpc 0x%lx ncnt %d\n",
 133                (unsigned long) n_lowpc, (unsigned long) n_highpc, ncnt);
 134        printf ("[hist_read_rec] s_lowpc 0x%lx s_highpc 0x%lx nsamples %d\n",
 135                (unsigned long) s_lowpc, (unsigned long) s_highpc,
 136                hist_num_bins);
 137        printf ("[hist_read_rec]   lowpc 0x%lx   highpc 0x%lx\n",
 138                (unsigned long) lowpc, (unsigned long) highpc));
 139
 140   if (n_lowpc != s_lowpc || n_highpc != s_highpc
 141       || ncnt != hist_num_bins || hz != profrate)
 142     {
 143       fprintf (stderr, _("%s: `%s' is incompatible with first gmon file\n"),
 144                whoami, filename);
 145       done (1);
 146     }
 147
 148   if (!hist_sample)
 149     {
 150       hist_sample = (int *) xmalloc (hist_num_bins * sizeof (hist_sample[0]));
 151       memset (hist_sample, 0, hist_num_bins * sizeof (hist_sample[0]));
 152     }
 153
 154   for (i = 0; i < hist_num_bins; ++i)
 155     {
 156       if (fread (&count[0], sizeof (count), 1, ifp) != 1)
 157         {
 158           fprintf (stderr,
 159                    _("%s: %s: unexpected EOF after reading %d of %d samples\n"),
 160                    whoami, filename, i, hist_num_bins);
 161           done (1);
 162         }
 163       hist_sample[i] += bfd_get_16 (core_bfd, (bfd_byte *) & count[0]);
 164     }
 165 }
 166
 167
 168 /*
 169  * Write execution histogram to file OFP.  FILENAME is the name
 170  * of OFP and is provided for formatting error-messages only.
 171  */
 172 void
 173 DEFUN (hist_write_hist, (ofp, filename), FILE * ofp AND const char *filename)
 174 {
 175   struct gmon_hist_hdr hdr;
 176   unsigned char tag;
 177   UNIT count;
 178   int i;
 179
 180   /* write header: */
 181
 182   tag = GMON_TAG_TIME_HIST;
 183   put_vma (core_bfd, s_lowpc, (bfd_byte *) hdr.low_pc);
 184   put_vma (core_bfd, s_highpc, (bfd_byte *) hdr.high_pc);
 185   bfd_put_32 (core_bfd, hist_num_bins, (bfd_byte *) hdr.hist_size);
 186   bfd_put_32 (core_bfd, hz, (bfd_byte *) hdr.prof_rate);
 187   strncpy (hdr.dimen, hist_dimension, sizeof (hdr.dimen));
 188   hdr.dimen_abbrev = hist_dimension_abbrev;
 189
 190   if (fwrite (&tag, sizeof (tag), 1, ofp) != 1
 191       || fwrite (&hdr, sizeof (hdr), 1, ofp) != 1)
 192     {
 193       perror (filename);
 194       done (1);
 195     }
 196
 197   for (i = 0; i < hist_num_bins; ++i)
 198     {
 199       bfd_put_16 (core_bfd, hist_sample[i], (bfd_byte *) & count[0]);
 200       if (fwrite (&count[0], sizeof (count), 1, ofp) != 1)
 201         {
 202           perror (filename);
 203           done (1);
 204         }
 205     }
 206 }
 207
 208
 209 /*
 210  * Calculate scaled entry point addresses (to save time in
 211  * hist_assign_samples), and, on architectures that have procedure
 212  * entry masks at the start of a function, possibly push the scaled
 213  * entry points over the procedure entry mask, if it turns out that
 214  * the entry point is in one bin and the code for a routine is in the
 215  * next bin.
 216  */
 217 static void
 218 scale_and_align_entries ()
 219 {
 220   Sym *sym;
 221   bfd_vma bin_of_entry;
 222   bfd_vma bin_of_code;
 223
 224   for (sym = symtab.base; sym < symtab.limit; sym++)
 225     {
 226       sym->hist.scaled_addr = sym->addr / sizeof (UNIT);
 227       bin_of_entry = (sym->hist.scaled_addr - lowpc) / hist_scale;
 228       bin_of_code = (sym->hist.scaled_addr + UNITS_TO_CODE - lowpc) / hist_scale;
 229       if (bin_of_entry < bin_of_code)
 230         {
 231           DBG (SAMPLEDEBUG,
 232                printf ("[scale_and_align_entries] pushing 0x%lx to 0x%lx\n",
 233                        (unsigned long) sym->hist.scaled_addr,
 234                        (unsigned long) (sym->hist.scaled_addr
 235                                         + UNITS_TO_CODE)));
 236           sym->hist.scaled_addr += UNITS_TO_CODE;
 237         }
 238     }
 239 }
 240
 241
 242 /*
 243  * Assign samples to the symbol to which they belong.
 244  *
 245  * Histogram bin I covers some address range [BIN_LOWPC,BIN_HIGH_PC)
 246  * which may overlap one more symbol address ranges.  If a symbol
 247  * overlaps with the bin's address range by O percent, then O percent
 248  * of the bin's count is credited to that symbol.
 249  *
 250  * There are three cases as to where BIN_LOW_PC and BIN_HIGH_PC can be
 251  * with respect to the symbol's address range [SYM_LOW_PC,
 252  * SYM_HIGH_PC) as shown in the following diagram.  OVERLAP computes
 253  * the distance (in UNITs) between the arrows, the fraction of the
 254  * sample that is to be credited to the symbol which starts at
 255  * SYM_LOW_PC.
 256  *
 257  *        sym_low_pc                                      sym_high_pc
 258  *             |                                               |
 259  *             v                                               v
 260  *
 261  *             +-----------------------------------------------+
 262  *             |                                               |
 263  *        |  ->|    |<-         ->|         |<-         ->|    |<-  |
 264  *        |         |             |         |             |         |
 265  *        +---------+             +---------+             +---------+
 266  *
 267  *        ^         ^             ^         ^             ^         ^
 268  *        |         |             |         |             |         |
 269  *   bin_low_pc bin_high_pc  bin_low_pc bin_high_pc  bin_low_pc bin_high_pc
 270  *
 271  * For the VAX we assert that samples will never fall in the first two
 272  * bytes of any routine, since that is the entry mask, thus we call
 273  * scale_and_align_entries() to adjust the entry points if the entry
 274  * mask falls in one bin but the code for the routine doesn't start
 275  * until the next bin.  In conjunction with the alignment of routine
 276  * addresses, this should allow us to have only one sample for every
 277  * four bytes of text space and never have any overlap (the two end
 278  * cases, above).
 279  */
 280 void
 281 DEFUN_VOID (hist_assign_samples)
 282 {
 283   bfd_vma bin_low_pc, bin_high_pc;
 284   bfd_vma sym_low_pc, sym_high_pc;
 285   bfd_vma overlap, addr;
 286   int bin_count, i;
 287   unsigned int j;
 288   double time, credit;
 289
 290   /* read samples and assign to symbols: */
 291   hist_scale = highpc - lowpc;
 292   hist_scale /= hist_num_bins;
 293   scale_and_align_entries ();
 294
 295   /* iterate over all sample bins: */
 296
 297   for (i = 0, j = 1; i < hist_num_bins; ++i)
 298     {
 299       bin_count = hist_sample[i];
 300       if (!bin_count)
 301         {
 302           continue;
 303         }
 304       bin_low_pc = lowpc + (bfd_vma) (hist_scale * i);
 305       bin_high_pc = lowpc + (bfd_vma) (hist_scale * (i + 1));
 306       time = bin_count;
 307       DBG (SAMPLEDEBUG,
 308            printf (
 309       "[assign_samples] bin_low_pc=0x%lx, bin_high_pc=0x%lx, bin_count=%d\n",
 310                     (unsigned long) (sizeof (UNIT) * bin_low_pc),
 311                     (unsigned long) (sizeof (UNIT) * bin_high_pc),
 312                     bin_count));
 313       total_time += time;
 314
 315       /* credit all symbols that are covered by bin I: */
 316
 317       for (j = j - 1; j < symtab.len; ++j)
 318         {
 319           sym_low_pc = symtab.base[j].hist.scaled_addr;
 320           sym_high_pc = symtab.base[j + 1].hist.scaled_addr;
 321           /*
 322            * If high end of bin is below entry address, go for next
 323            * bin:
 324            */
 325           if (bin_high_pc < sym_low_pc)
 326             {
 327               break;
 328             }
 329           /*
 330            * If low end of bin is above high end of symbol, go for
 331            * next symbol.
 332            */
 333           if (bin_low_pc >= sym_high_pc)
 334             {
 335               continue;
 336             }
 337           overlap =
 338             MIN (bin_high_pc, sym_high_pc) - MAX (bin_low_pc, sym_low_pc);
 339           if (overlap > 0)
 340             {
 341               DBG (SAMPLEDEBUG,
 342                    printf (
 343                             "[assign_samples] [0x%lx,0x%lx) %s gets %f ticks %ld overlap\n",
 344                             (unsigned long) symtab.base[j].addr,
 345                             (unsigned long) (sizeof (UNIT) * sym_high_pc),
 346                             symtab.base[j].name, overlap * time / hist_scale,
 347                             (long) overlap));
 348               addr = symtab.base[j].addr;
 349               credit = overlap * time / hist_scale;
 350               /*
 351                * Credit symbol if it appears in INCL_FLAT or that
 352                * table is empty and it does not appear it in
 353                * EXCL_FLAT.
 354                */
 355               if (sym_lookup (&syms[INCL_FLAT], addr)
 356                   || (syms[INCL_FLAT].len == 0
 357                       && !sym_lookup (&syms[EXCL_FLAT], addr)))
 358                 {
 359                   symtab.base[j].hist.time += credit;
 360                 }
 361               else
 362                 {
 363                   total_time -= credit;
 364                 }
 365             }
 366         }
 367     }
 368   DBG (SAMPLEDEBUG, printf ("[assign_samples] total_time %f\n",
 369                             total_time));
 370 }
 371
 372
 373 /*
 374  * Print header for flag histogram profile:
 375  */
 376 static void
 377 DEFUN (print_header, (prefix), const char prefix)
 378 {
 379   char unit[64];
 380
 381   sprintf (unit, _("%c%c/call"), prefix, hist_dimension_abbrev);
 382
 383   if (bsd_style_output)
 384     {
 385       printf (_("\ngranularity: each sample hit covers %ld byte(s)"),
 386               (long) hist_scale * sizeof (UNIT));
 387       if (total_time > 0.0)
 388         {
 389           printf (_(" for %.2f%% of %.2f %s\n\n"),
 390                   100.0 / total_time, total_time / hz, hist_dimension);
 391         }
 392     }
 393   else
 394     {
 395       printf (_("\nEach sample counts as %g %s.\n"), 1.0 / hz, hist_dimension);
 396     }
 397
 398   if (total_time <= 0.0)
 399     {
 400       printf (_(" no time accumulated\n\n"));
 401       /* this doesn't hurt since all the numerators will be zero: */
 402       total_time = 1.0;
 403     }
 404
 405   printf ("%5.5s %10.10s %8.8s %8.8s %8.8s %8.8s  %-8.8s\n",
 406           "%  ", _("cumulative"), _("self  "), "", _("self  "), _("total "), "");
 407   printf ("%5.5s %9.9s  %8.8s %8.8s %8.8s %8.8s  %-8.8s\n",
 408           _("time"), hist_dimension, hist_dimension, _("calls"), unit, unit,
 409           _("name"));
 410 }
 411
 412
 413 static void
 414 DEFUN (print_line, (sym, scale), Sym * sym AND double scale)
 415 {
 416   if (ignore_zeros && sym->ncalls == 0 && sym->hist.time == 0)
 417     {
 418       return;
 419     }
 420
 421   accum_time += sym->hist.time;
 422   if (bsd_style_output)
 423     {
 424       printf ("%5.1f %10.2f %8.2f",
 425               total_time > 0.0 ? 100 * sym->hist.time / total_time : 0.0,
 426               accum_time / hz, sym->hist.time / hz);
 427     }
 428   else
 429     {
 430       printf ("%6.2f %9.2f %8.2f",
 431               total_time > 0.0 ? 100 * sym->hist.time / total_time : 0.0,
 432               accum_time / hz, sym->hist.time / hz);
 433     }
 434   if (sym->ncalls != 0)
 435     {
 436       printf (" %8lu %8.2f %8.2f  ",
 437               sym->ncalls, scale * sym->hist.time / hz / sym->ncalls,
 438           scale * (sym->hist.time + sym->cg.child_time) / hz / sym->ncalls);
 439     }
 440   else
 441     {
 442       printf (" %8.8s %8.8s %8.8s  ", "", "", "");
 443     }
 444   if (bsd_style_output)
 445     {
 446       print_name (sym);
 447     }
 448   else
 449     {
 450       print_name_only (sym);
 451     }
 452   printf ("\n");
 453 }
 454
 455
 456 /*
 457  * Compare LP and RP.  The primary comparison key is execution time,
 458  * the secondary is number of invocation, and the tertiary is the
 459  * lexicographic order of the function names.
 460  */
 461 static int
 462 DEFUN (cmp_time, (lp, rp), const PTR lp AND const PTR rp)
 463 {
 464   const Sym *left = *(const Sym **) lp;
 465   const Sym *right = *(const Sym **) rp;
 466   double time_diff;
 467
 468   time_diff = right->hist.time - left->hist.time;
 469   if (time_diff > 0.0)
 470     {
 471       return 1;
 472     }
 473   if (time_diff < 0.0)
 474     {
 475       return -1;
 476     }
 477
 478   if (right->ncalls > left->ncalls)
 479     {
 480       return 1;
 481     }
 482   if (right->ncalls < left->ncalls)
 483     {
 484       return -1;
 485     }
 486
 487   return strcmp (left->name, right->name);
 488 }
 489
 490
 491 /*
 492  * Print the flat histogram profile.
 493  */
 494 void
 495 DEFUN_VOID (hist_print)
 496 {
 497   Sym **time_sorted_syms, *top_dog, *sym;
 498   unsigned int index;
 499   int log_scale;
 500   double top_time, time;
 501   bfd_vma addr;
 502
 503   if (first_output)
 504     {
 505       first_output = FALSE;
 506     }
 507   else
 508     {
 509       printf ("\f\n");
 510     }
 511
 512   accum_time = 0.0;
 513   if (bsd_style_output)
 514     {
 515       if (print_descriptions)
 516         {
 517           printf (_("\n\n\nflat profile:\n"));
 518           flat_blurb (stdout);
 519         }
 520     }
 521   else
 522     {
 523       printf (_("Flat profile:\n"));
 524     }
 525   /*
 526    * Sort the symbol table by time (call-count and name as secondary
 527    * and tertiary keys):
 528    */
 529   time_sorted_syms = (Sym **) xmalloc (symtab.len * sizeof (Sym *));
 530   for (index = 0; index < symtab.len; ++index)
 531     {
 532       time_sorted_syms[index] = &symtab.base[index];
 533     }
 534   qsort (time_sorted_syms, symtab.len, sizeof (Sym *), cmp_time);
 535
 536   if (bsd_style_output)
 537     {
 538       log_scale = 5;            /* milli-seconds is BSD-default */
 539     }
 540   else
 541     {
 542       /*
 543        * Search for symbol with highest per-call execution time and
 544        * scale accordingly:
 545        */
 546       log_scale = 0;
 547       top_dog = 0;
 548       top_time = 0.0;
 549       for (index = 0; index < symtab.len; ++index)
 550         {
 551           sym = time_sorted_syms[index];
 552           if (sym->ncalls != 0)
 553             {
 554               time = (sym->hist.time + sym->cg.child_time) / sym->ncalls;
 555               if (time > top_time)
 556                 {
 557                   top_dog = sym;
 558                   top_time = time;
 559                 }
 560             }
 561         }
 562       if (top_dog && top_dog->ncalls != 0 && top_time > 0.0)
 563         {
 564           top_time /= hz;
 565           while (SItab[log_scale].scale * top_time < 1000.0
 566                  && ((size_t) log_scale
 567                      < sizeof (SItab) / sizeof (SItab[0]) - 1))
 568             {
 569               ++log_scale;
 570             }
 571         }
 572     }
 573
 574   /*
 575    * For now, the dimension is always seconds.  In the future, we
 576    * may also want to support other (pseudo-)dimensions (such as
 577    * I-cache misses etc.).
 578    */
 579   print_header (SItab[log_scale].prefix);
 580   for (index = 0; index < symtab.len; ++index)
 581     {
 582       addr = time_sorted_syms[index]->addr;
 583       /*
 584        * Print symbol if its in INCL_FLAT table or that table
 585        * is empty and the symbol is not in EXCL_FLAT.
 586        */
 587       if (sym_lookup (&syms[INCL_FLAT], addr)
 588           || (syms[INCL_FLAT].len == 0
 589               && !sym_lookup (&syms[EXCL_FLAT], addr)))
 590         {
 591           print_line (time_sorted_syms[index], SItab[log_scale].scale);
 592         }
 593     }
 594   free (time_sorted_syms);
 595
 596   if (print_descriptions && !bsd_style_output)
 597     {
 598       flat_blurb (stdout);
 599     }
 600 }