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