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