malloc/memusagestat.c

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