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