malloc/memusagestat.c

   1 /* Generate graphic from memory profiling data.
   2    Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library 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 GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, write to the Free
  18    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19    02111-1307 USA.  */
  20
  21 #define _FILE_OFFSET_BITS 64
  22
  23 #include <argp.h>
  24 #include <assert.h>
  25 #include <errno.h>
  26 #include <error.h>
  27 #include <fcntl.h>
  28 #include <getopt.h>
  29 #include <inttypes.h>
  30 #include <libintl.h>
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34 #include <unistd.h>
  35 #include <sys/param.h>
  36 #include <sys/stat.h>
  37
  38 #include <gd.h>
  39 #include <gdfontl.h>
  40 #include <gdfonts.h>
  41
  42
  43 /* Default size of the generated image.  */
  44 #define XSIZE 800
  45 #define YSIZE 600
  46
  47 #ifndef N_
  48 # define N_(Arg) Arg
  49 #endif
  50
  51
  52 /* Definitions of arguments for argp functions.  */
  53 static const struct argp_option options[] =
  54 {
  55   { "output", 'o', "FILE", 0, N_("Name output file") },
  56   { "string", 's', "STRING", 0, N_("Title string used in output graphic") },
  57   { "time", 't', NULL, 0, N_("Generate output linear to time (default is linear to number of function calls)") },
  58   { "total", 'T', NULL, 0,
  59     N_("Also draw graph for total memory consumption") },
  60   { "x-size", 'x', "VALUE", 0, N_("make output graphic VALUE pixel wide") },
  61   { "y-size", 'y', "VALUE", 0, N_("make output graphic VALUE pixel high") },
  62   { NULL, 0, NULL, 0, NULL }
  63 };
  64
  65 /* Short description of program.  */
  66 static const char doc[] = N_("Generate graphic from memory profiling data");
  67
  68 /* Strings for arguments in help texts.  */
  69 static const char args_doc[] = N_("DATAFILE [OUTFILE]");
  70
  71 /* Prototype for option handler.  */
  72 static error_t parse_opt (int key, char *arg, struct argp_state *state);
  73
  74 /* Function to print some extra text in the help message.  */
  75 static char *more_help (int key, const char *text, void *input);
  76
  77 /* Data structure to communicate with argp functions.  */
  78 static struct argp argp =
  79 {
  80   options, parse_opt, args_doc, doc, NULL, more_help
  81 };
  82
  83
  84 struct entry
  85 {
  86   size_t heap;
  87   size_t stack;
  88   uint32_t time_low;
  89   uint32_t time_high;
  90 };
  91
  92
  93 /* Size of the image.  */
  94 static size_t xsize;
  95 static size_t ysize;
  96
  97 /* Name of the output file.  */
  98 static char *outname;
  99
 100 /* Title string for the graphic.  */
 101 static const char *string;
 102
 103 /* Nonzero if graph should be generated linear in time.  */
 104 static int time_based;
 105
 106 /* Nonzero if graph to display total use of memory should be drawn as well.  */
 107 static int also_total = 0;
 108
 109
 110 int
 111 main (int argc, char *argv[])
 112 {
 113   int remaining;
 114   const char *inname;
 115   gdImagePtr im_out;
 116   int grey, blue, red, green, yellow, black;
 117   int fd;
 118   struct stat st;
 119   size_t maxsize_heap;
 120   size_t maxsize_stack;
 121   size_t maxsize_total;
 122   uint64_t total;
 123   uint64_t cnt, cnt2;
 124   FILE *outfile;
 125   char buf[30];
 126   size_t last_heap;
 127   size_t last_stack;
 128   size_t last_total;
 129   struct entry headent[2];
 130   uint64_t start_time;
 131   uint64_t end_time;
 132   uint64_t total_time;
 133   const char *heap_format, *stack_format;
 134   int heap_scale, stack_scale, line;
 135
 136   outname = NULL;
 137   xsize = XSIZE;
 138   ysize = YSIZE;
 139   string = NULL;
 140
 141   /* Parse and process arguments.  */
 142   argp_parse (&argp, argc, argv, 0, &remaining, NULL);
 143
 144   if (remaining >= argc || remaining + 2 < argc)
 145     {
 146       argp_help (&argp, stdout, ARGP_HELP_SEE | ARGP_HELP_EXIT_ERR,
 147                  program_invocation_short_name);
 148       exit (1);
 149     }
 150
 151   inname = argv[remaining++];
 152
 153   if (remaining < argc)
 154     outname = argv[remaining];
 155   else if (outname == NULL)
 156     {
 157       size_t len = strlen (inname);
 158       outname = alloca (len + 5);
 159       stpcpy (stpcpy (outname, inname), ".png");
 160     }
 161
 162   /* Open for read/write since we try to repair the file in case the
 163      application hasn't terminated cleanly.  */
 164   fd = open (inname, O_RDWR);
 165   if (fd == -1)
 166     error (EXIT_FAILURE, errno, "cannot open input file");
 167   if (fstat (fd, &st) != 0)
 168     {
 169       close (fd);
 170       error (EXIT_FAILURE, errno, "cannot get size of input file");
 171     }
 172   /* Test whether the file contains only full records.  */
 173   if ((st.st_size % sizeof (struct entry)) != 0
 174       /* The file must at least contain the two administrative records.  */
 175       || st.st_size < 2 * sizeof (struct entry))
 176     {
 177       close (fd);
 178       error (EXIT_FAILURE, 0, "input file as incorrect size");
 179     }
 180   /* Compute number of data entries.  */
 181   total = st.st_size / sizeof (struct entry) - 2;
 182
 183   /* Read the administrative information.  */
 184   read (fd, headent, sizeof (headent));
 185   maxsize_heap = headent[1].heap;
 186   maxsize_stack = headent[1].stack;
 187   maxsize_total = headent[0].stack;
 188   if (also_total)
 189     {
 190       /* We use one scale and since we also draw the total amount of
 191          memory used we have to adapt the maximum.  */
 192       maxsize_heap = maxsize_total;
 193       maxsize_stack = maxsize_total;
 194     }
 195
 196   if (maxsize_heap == 0 && maxsize_stack == 0)
 197     {
 198       /* The program aborted before memusage was able to write the
 199          information about the maximum heap and stack use.  Repair
 200          the file now.  */
 201       struct entry next;
 202
 203       while (1)
 204         {
 205           if (read (fd, &next, sizeof (next)) == 0)
 206             break;
 207           if (next.heap > headent[1].heap)
 208             headent[1].heap = next.heap;
 209           if (next.stack > headent[1].stack)
 210             headent[1].stack = next.stack;
 211         }
 212
 213       headent[1].time_low = next.time_low;
 214       headent[1].time_high = next.time_high;
 215
 216       /* Write the computed values in the file.  */
 217       lseek (fd, sizeof (struct entry), SEEK_SET);
 218       write (fd, &headent[1], sizeof (struct entry));
 219     }
 220
 221   start_time = ((uint64_t) headent[0].time_high) << 32 | headent[0].time_low;
 222   end_time = ((uint64_t) headent[1].time_high) << 32 | headent[1].time_low;
 223   total_time = end_time - start_time;
 224
 225   if (xsize < 100)
 226     xsize = 100;
 227   if (ysize < 80)
 228     ysize = 80;
 229
 230   /* Create output image with the specified size.  */
 231   im_out = gdImageCreate (xsize, ysize);
 232
 233   /* First color allocated is background.  */
 234   grey = gdImageColorAllocate (im_out, 224, 224, 224);
 235
 236   /* Set transparent color. */
 237   gdImageColorTransparent (im_out, grey);
 238
 239   /* These are all the other colors we need (in the moment).  */
 240   red = gdImageColorAllocate (im_out, 255, 0, 0);
 241   green = gdImageColorAllocate (im_out, 0, 130, 0);
 242   blue = gdImageColorAllocate (im_out, 0, 0, 255);
 243   yellow = gdImageColorAllocate (im_out, 154, 205, 50);
 244   black = gdImageColorAllocate (im_out, 0, 0, 0);
 245
 246   gdImageRectangle (im_out, 40, 20, xsize - 40, ysize - 20, blue);
 247
 248   if (maxsize_heap < 1024)
 249     {
 250       heap_format = "%Zu";
 251       heap_scale = 1;
 252     }
 253   else if (maxsize_heap < 1024 * 1024 * 100)
 254     {
 255       heap_format = "%Zuk";
 256       heap_scale = 1024;
 257     }
 258   else
 259     {
 260       heap_format = "%ZuM";
 261       heap_scale = 1024 * 1024;
 262     }
 263
 264   if (maxsize_stack < 1024)
 265     {
 266       stack_format = "%Zu";
 267       stack_scale = 1;
 268     }
 269   else if (maxsize_stack < 1024 * 1024 * 100)
 270     {
 271       stack_format = "%Zuk";
 272       stack_scale = 1024;
 273     }
 274   else
 275     {
 276       stack_format = "%ZuM";
 277       stack_scale = 1024 * 1024;
 278     }
 279
 280   gdImageString (im_out, gdFontSmall, 38, ysize - 14, (unsigned char *) "0",
 281                  blue);
 282   snprintf(buf, sizeof (buf), heap_format, 0);
 283   gdImageString (im_out, gdFontSmall, maxsize_heap < 1024 ? 32 : 26,
 284                  ysize - 26, buf, red);
 285   snprintf(buf, sizeof (buf), stack_format, 0);
 286   gdImageString (im_out, gdFontSmall, xsize - 37, ysize - 26,
 287                  buf, green);
 288
 289   if (string != NULL)
 290     gdImageString (im_out, gdFontLarge, (xsize - strlen (string) * 8) / 2,
 291                    2, (char *) string, green);
 292
 293   gdImageStringUp (im_out, gdFontSmall, 1, ysize / 2 - 10,
 294                    (unsigned char *) "allocated", red);
 295   gdImageStringUp (im_out, gdFontSmall, 11, ysize / 2 - 10,
 296                    (unsigned char *) "memory", red);
 297
 298   gdImageStringUp (im_out, gdFontSmall, xsize - 39, ysize / 2 - 10,
 299                    (unsigned char *) "used", green);
 300   gdImageStringUp (im_out, gdFontSmall, xsize - 27, ysize / 2 - 10,
 301                    (unsigned char *) "stack", green);
 302
 303   snprintf (buf, sizeof (buf), heap_format, maxsize_heap / heap_scale);
 304   gdImageString (im_out, gdFontSmall, 39 - strlen (buf) * 6, 14, buf, red);
 305   snprintf (buf, sizeof (buf), stack_format, maxsize_stack / stack_scale);
 306   gdImageString (im_out, gdFontSmall, xsize - 37, 14, buf, green);
 307
 308   for (line = 1; line <= 3; ++line)
 309     {
 310       cnt = ((ysize - 40) * (maxsize_heap / 4 * line / heap_scale)) /
 311         (maxsize_heap / heap_scale);
 312       gdImageDashedLine (im_out, 40, ysize - 20 - cnt, xsize - 40,
 313                          ysize - 20 - cnt, red);
 314       snprintf (buf, sizeof (buf), heap_format, maxsize_heap / 4 * line /
 315                 heap_scale);
 316       gdImageString (im_out, gdFontSmall, 39 - strlen (buf) * 6,
 317                      ysize - 26 - cnt, buf, red);
 318
 319       cnt2 = ((ysize - 40) * (maxsize_stack / 4 * line / stack_scale)) /
 320         (maxsize_stack / stack_scale);
 321       if (cnt != cnt2)
 322         gdImageDashedLine (im_out, 40, ysize - 20 - cnt2, xsize - 40,
 323                            ysize - 20 - cnt2, green);
 324       snprintf (buf, sizeof (buf), stack_format, maxsize_stack / 4 * line /
 325                 stack_scale);
 326       gdImageString (im_out, gdFontSmall, xsize - 37, ysize - 26 - cnt2,
 327                      buf, green);
 328     }
 329
 330   snprintf (buf, sizeof (buf), "%llu", (unsigned long long) total);
 331   gdImageString (im_out, gdFontSmall, xsize - 50, ysize - 14, buf, blue);
 332
 333   if (!time_based)
 334     {
 335       uint64_t previously = start_time;
 336
 337       gdImageString (im_out, gdFontSmall, 40 + (xsize - 32 * 6 - 80) / 2,
 338                      ysize - 12,
 339                      (unsigned char *) "# memory handling function calls",
 340                      blue);
 341
 342
 343       last_stack = last_heap = last_total = ysize - 20;
 344       for (cnt = 1; cnt <= total; ++cnt)
 345         {
 346           struct entry entry;
 347           size_t new[2];
 348           uint64_t now;
 349
 350           read (fd, &entry, sizeof (entry));
 351
 352           now = ((uint64_t) entry.time_high) << 32 | entry.time_low;
 353
 354           if ((((previously - start_time) * 100) / total_time) % 10 < 5)
 355             gdImageFilledRectangle (im_out,
 356                                     40 + ((cnt - 1) * (xsize - 80)) / total,
 357                                     ysize - 19,
 358                                     39 + (cnt * (xsize - 80)) / total,
 359                                     ysize - 14, yellow);
 360           previously = now;
 361
 362           if (also_total)
 363             {
 364               size_t new3;
 365
 366               new3 = (ysize - 20) - ((((unsigned long long int) (ysize - 40))
 367                                       * (entry.heap + entry.stack))
 368                                      / maxsize_heap);
 369               gdImageLine (im_out, 40 + ((xsize - 80) * (cnt - 1)) / total,
 370                            last_total,
 371                            40 + ((xsize - 80) * cnt) / total, new3,
 372                            black);
 373               last_total = new3;
 374             }
 375
 376           // assert (entry.heap <= maxsize_heap);
 377           new[0] = (ysize - 20) - ((((unsigned long long int) (ysize - 40))
 378                                     * entry.heap) / maxsize_heap);
 379           gdImageLine (im_out, 40 + ((xsize - 80) * (cnt - 1)) / total,
 380                        last_heap, 40 + ((xsize - 80) * cnt) / total, new[0],
 381                        red);
 382           last_heap = new[0];
 383
 384           // assert (entry.stack <= maxsize_stack);
 385           new[1] = (ysize - 20) - ((((unsigned long long int) (ysize - 40))
 386                                     * entry.stack) / maxsize_stack);
 387           gdImageLine (im_out, 40 + ((xsize - 80) * (cnt - 1)) / total,
 388                        last_stack, 40 + ((xsize - 80) * cnt) / total, new[1],
 389                        green);
 390           last_stack = new[1];
 391         }
 392
 393       cnt = 0;
 394       while (cnt < total)
 395         {
 396           gdImageLine (im_out, 40 + ((xsize - 80) * cnt) / total, ysize - 20,
 397                        40 + ((xsize - 80) * cnt) / total, ysize - 15, blue);
 398           cnt += MAX (1, total / 20);
 399         }
 400       gdImageLine (im_out, xsize - 40, ysize - 20, xsize - 40, ysize - 15,
 401                    blue);
 402     }
 403   else
 404     {
 405       uint64_t next_tick = MAX (1, total / 20);
 406       size_t last_xpos = 40;
 407
 408       gdImageString (im_out, gdFontSmall, 40 + (xsize - 39 * 6 - 80) / 2,
 409                      ysize - 12,
 410                      (unsigned char *) "\
 411 # memory handling function calls / time", blue);
 412
 413       for (cnt = 0; cnt < 20; cnt += 2)
 414         gdImageFilledRectangle (im_out,
 415                                 40 + (cnt * (xsize - 80)) / 20, ysize - 19,
 416                                 39 + ((cnt + 1) * (xsize - 80)) / 20,
 417                                 ysize - 14, yellow);
 418
 419       last_stack = last_heap = last_total = ysize - 20;
 420       for (cnt = 1; cnt <= total; ++cnt)
 421         {
 422           struct entry entry;
 423           size_t new[2];
 424           size_t xpos;
 425           uint64_t now;
 426
 427           read (fd, &entry, sizeof (entry));
 428
 429           now = ((uint64_t) entry.time_high) << 32 | entry.time_low;
 430           xpos = 40 + ((xsize - 80) * (now - start_time)) / total_time;
 431
 432           if (cnt == next_tick)
 433             {
 434               gdImageLine (im_out, xpos, ysize - 20, xpos, ysize - 15, blue);
 435               next_tick += MAX (1, total / 20);
 436             }
 437
 438           if (also_total)
 439             {
 440               size_t new3;
 441
 442               new3 = (ysize - 20) - ((((unsigned long long int) (ysize - 40))
 443                                       * (entry.heap + entry.stack))
 444                                      / maxsize_heap);
 445               gdImageLine (im_out, last_xpos, last_total, xpos, new3, black);
 446               last_total = new3;
 447             }
 448
 449           new[0] = (ysize - 20) - ((((unsigned long long int) (ysize - 40))
 450                                     * entry.heap) / maxsize_heap);
 451           gdImageLine (im_out, last_xpos, last_heap, xpos, new[0], red);
 452           last_heap = new[0];
 453
 454           // assert (entry.stack <= maxsize_stack);
 455           new[1] = (ysize - 20) - ((((unsigned long long int) (ysize - 40))
 456                                     * entry.stack) / maxsize_stack);
 457           gdImageLine (im_out, last_xpos, last_stack, xpos, new[1], green);
 458           last_stack = new[1];
 459
 460           last_xpos = xpos;
 461         }
 462     }
 463
 464   /* Write out the result.  */
 465   outfile = fopen (outname, "w");
 466   if (outfile == NULL)
 467     error (EXIT_FAILURE, errno, "cannot open output file");
 468
 469   gdImagePng (im_out, outfile);
 470
 471   fclose (outfile);
 472
 473   gdImageDestroy (im_out);
 474
 475   return 0;
 476 }
 477
 478
 479 /* Handle program arguments.  */
 480 static error_t
 481 parse_opt (int key, char *arg, struct argp_state *state)
 482 {
 483   switch (key)
 484     {
 485     case 'o':
 486       outname = arg;
 487       break;
 488     case 's':
 489       string = arg;
 490       break;
 491     case 't':
 492       time_based = 1;
 493       break;
 494     case 'T':
 495       also_total = 1;
 496       break;
 497     case 'x':
 498       xsize = atoi (arg);
 499       if (xsize == 0)
 500         xsize = XSIZE;
 501       break;
 502     case 'y':
 503       ysize = atoi (arg);
 504       if (ysize == 0)
 505         ysize = XSIZE;
 506       break;
 507     default:
 508       return ARGP_ERR_UNKNOWN;
 509     }
 510   return 0;
 511 }
 512
 513
 514 static char *
 515 more_help (int key, const char *text, void *input)
 516 {
 517   char *orig;
 518   char *cp;
 519
 520   switch (key)
 521     {
 522     case ARGP_KEY_HELP_EXTRA:
 523       /* We print some extra information.  */
 524       orig = gettext ("\
 525 For bug reporting instructions, please see:\n\
 526 <http://www.gnu.org/software/libc/bugs.html>.\n");
 527       cp = strdup (orig);
 528       if (cp == NULL)
 529         cp = orig;
 530       return cp;
 531     default:
 532       break;
 533     }
 534   return (char *) text;
 535 }