[libc] (GLIBC_2.2): Add posix_memalign.
[kopensolaris-gnu/glibc.git] / malloc / memprof.c
1 /* Profile heap and stack memory usage of running program.
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 <dlfcn.h>
22 #include <fcntl.h>
23 #include <inttypes.h>
24 #include <signal.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <unistd.h>
29 #include <sys/time.h>
30
31 #include <memprof.h>
32
33 /* Pointer to the real functions.  These are determined used `dlsym'
34    when really needed.  */
35 static void *(*mallocp) (size_t);
36 static void *(*reallocp) (void *, size_t);
37 static void *(*callocp) (size_t, size_t);
38 static void (*freep) (void *);
39
40 enum
41 {
42   idx_malloc = 0,
43   idx_realloc,
44   idx_calloc,
45   idx_free,
46   idx_last
47 };
48
49
50 struct header
51 {
52   size_t length;
53   size_t magic;
54 };
55
56 #define MAGIC 0xfeedbeaf
57
58
59 static unsigned long int calls[idx_last];
60 static unsigned long int failed[idx_last];
61 static unsigned long long int total[idx_last];
62 static unsigned long long int grand_total;
63 static unsigned long int histogram[65536 / 16];
64 static unsigned long int large;
65 static unsigned long int calls_total;
66 static unsigned long int inplace;
67 static unsigned long int decreasing;
68 static long int current_use[2];
69 static long int peak_use[3];
70 static uintptr_t start_sp;
71
72 /* A few macros to make the source more readable.  */
73 #define current_heap    current_use[0]
74 #define current_stack   current_use[1]
75 #define peak_heap       peak_use[0]
76 #define peak_stack      peak_use[1]
77 #define peak_total      peak_use[2]
78
79 #define DEFAULT_BUFFER_SIZE     1024
80 static size_t buffer_size;
81
82 static int fd = -1;
83
84 static int not_me;
85 extern const char *__progname;
86
87 struct entry
88 {
89   size_t heap;
90   size_t stack;
91   uint32_t time_low;
92   uint32_t time_high;
93 };
94
95 static struct entry buffer[DEFAULT_BUFFER_SIZE];
96 static size_t buffer_cnt;
97 static struct entry first;
98
99
100 /* Update the global data after a successful function call.  */
101 static void
102 update_data (struct header *result, size_t len, size_t old_len)
103 {
104   long int total_use;
105
106   if (result != NULL)
107     {
108       /* Record the information we need and mark the block using a
109          magic number.  */
110       result->length = len;
111       result->magic = MAGIC;
112     }
113
114   /* Compute current heap usage and compare it with the maximum value.  */
115   current_heap += len - old_len;
116   if (current_heap > peak_heap)
117     peak_heap = current_heap;
118
119   /* Compute current stack usage and compare it with the maximum value.  */
120   current_stack = start_sp - GETSP ();
121   if (current_stack > peak_stack)
122     peak_stack = current_stack;
123
124   /* Add up heap and stack usage and compare it with the maximum value.  */
125   total_use = current_heap + current_stack;
126   if (total_use > peak_total)
127     peak_total = total_use;
128
129   /* Store the value only if we are writing to a file.  */
130   if (fd != -1)
131     {
132       buffer[buffer_cnt].heap = current_heap;
133       buffer[buffer_cnt].stack = current_stack;
134       GETTIME (buffer[buffer_cnt].time_low, buffer[buffer_cnt].time_high);
135       ++buffer_cnt;
136
137       /* Write out buffer if it is full.  */
138       if (buffer_cnt == buffer_size)
139         {
140           write (fd, buffer, buffer_cnt * sizeof (struct entry));
141           buffer_cnt = 0;
142         }
143     }
144 }
145
146
147 /* Interrupt handler.  */
148 static void
149 int_handler (int signo)
150 {
151   /* Nothing gets allocated.  Just record the stack pointer position.  */
152   update_data (NULL, 0, 0);
153 }
154
155
156 /* Record the initial stack position.  */
157 static void
158 __attribute__ ((constructor))
159 init (void)
160 {
161   start_sp = GETSP ();
162 }
163
164
165 /* Find out whether this is the program we are supposed to profile.
166    For this the name in the variable `__progname' must match the one
167    given in the environment variable MEMPROF_PROG_NAME.  If the variable
168    is not present every program assumes it should be profiling.
169
170    If this is the program open a file descriptor to the output file.
171    We will write to it whenever the buffer overflows.  The name of the
172    output file is determined by the environment variable MEMPROF_OUTPUT.
173
174    If the environment variable MEMPROF_BUFFER_SIZE is set its numerical
175    value determines the size of the internal buffer.  The number gives
176    the number of elements in the buffer.  By setting the number to one
177    one effectively selects unbuffered operation.
178
179    If MEMPROF_NO_TIMER is not present an alarm handler is installed
180    which at the highest possible frequency records the stack pointer.  */
181 static void
182 me (void)
183 {
184   const char *env = getenv ("MEMPROF_PROG_NAME");
185   size_t prog_len = strlen (__progname);
186   if (env != NULL)
187     {
188       /* Check for program name.  */
189       size_t len = strlen (env);
190       if (len > prog_len || strcmp (env, &__progname[prog_len - len]) != 0
191           || (prog_len != len && __progname[prog_len - len - 1] != '/'))
192         not_me = 1;
193     }
194
195   /* Only open the file if it's really us.  */
196   if (!not_me && fd == -1)
197     {
198       const char *outname = getenv ("MEMPROF_OUTPUT");
199       if (outname != NULL)
200         {
201           fd = creat (outname, 0666);
202
203           if (fd == -1)
204             /* Don't do anything in future calls if we cannot write to
205                the output file.  */
206             not_me = 1;
207           else
208             {
209               /* Write the first entry.  */
210               first.heap = 0;
211               first.stack = 0;
212               GETTIME (first.time_low, first.time_high);
213               /* Write it two times since we need the starting and end time. */
214               write (fd, &first, sizeof (first));
215
216               /* Determine the buffer size.  We use the default if the
217                  environment variable is not present.  */
218               buffer_size = DEFAULT_BUFFER_SIZE;
219               if (getenv ("MEMPROF_BUFFER_SIZE") != NULL)
220                 {
221                   buffer_size = atoi (getenv ("MEMPROF_BUFFER_SIZE"));
222                   if (buffer_size == 0 || buffer_size > DEFAULT_BUFFER_SIZE)
223                     buffer_size = DEFAULT_BUFFER_SIZE;
224                 }
225
226               /* Possibly enable timer-based stack pointer retrieval.  */
227               if (getenv ("MEMPROF_NO_TIMER") == NULL)
228                 {
229                   struct sigaction act;
230
231                   act.sa_handler = (sighandler_t) &int_handler;
232                   act.sa_flags = SA_RESTART;
233                   sigfillset (&act.sa_mask);
234
235                   if (sigaction (SIGPROF, &act, NULL) >= 0)
236                     {
237                       struct itimerval timer;
238
239                       timer.it_value.tv_sec = 0;
240                       timer.it_value.tv_usec = 1;
241                       timer.it_interval = timer.it_value;
242                       setitimer (ITIMER_PROF, &timer, NULL);
243                     }
244                 }
245             }
246         }
247     }
248 }
249
250
251 /* `malloc' replacement.  We keep track of the memory usage if this is the
252    correct program.  */
253 void *
254 malloc (size_t len)
255 {
256   struct header *result = NULL;
257
258   /* Determine real implementation if not already happened.  */
259   if (mallocp == NULL)
260     {
261       me ();
262       mallocp = (void *(*) (size_t)) dlsym (RTLD_NEXT, "malloc");
263     }
264
265   /* If this is not the correct program just use the normal function.  */
266   if (not_me)
267     return (*mallocp) (len);
268
269   /* Keep track of number of calls.  */
270   ++calls[idx_malloc];
271   /* Keep track of total memory consumption for `malloc'.  */
272   total[idx_malloc] += len;
273   /* Keep track of total memory requirement.  */
274   grand_total += len;
275   /* Remember the size of the request.  */
276   if (len < 65536)
277     ++histogram[len / 16];
278   else
279     ++large;
280   /* Total number of calls of any of the functions.  */
281   ++calls_total;
282
283   /* Do the real work.  */
284   result = (struct header *) (*mallocp) (len + sizeof (struct header));
285
286   if (result == NULL)
287     ++failed[idx_malloc];
288   else
289     /* Update the allocation data and write out the records if necessary.  */
290     update_data (result, len, 0);
291
292   /* Return the pointer to the user buffer.  */
293   return result ? (void *) (result + 1) : NULL;
294 }
295
296
297 /* `realloc' replacement.  We keep track of the memory usage if this is the
298    correct program.  */
299 void *
300 realloc (void *old, size_t len)
301 {
302   struct header *result = NULL;
303   struct header *real;
304   size_t old_len;
305
306   /* Determine real implementation if not already happened.  */
307   if (reallocp == NULL)
308     {
309       me ();
310       reallocp = (void *(*) (void *, size_t)) dlsym (RTLD_NEXT, "realloc");
311     }
312
313   /* If this is not the correct program just use the normal function.  */
314   if (not_me)
315     return (*reallocp) (old, len);
316
317   if (old == NULL)
318     {
319       /* This is really a `malloc' call.  */
320       real = NULL;
321       old_len = 0;
322     }
323   else
324     {
325       real = ((struct header *) old) - 1;
326       if (real->magic != MAGIC)
327         /* This is no memory allocated here.  */
328         return (*reallocp) (old, len);
329       old_len = real->length;
330     }
331
332   /* Keep track of number of calls.  */
333   ++calls[idx_realloc];
334   /* Keep track of total memory consumption for `realloc'.  */
335   total[idx_realloc] += len;
336   /* Keep track of total memory requirement.  */
337   grand_total += len;
338   /* Remember the size of the request.  */
339   if (len < 65536)
340     ++histogram[len / 16];
341   else
342     ++large;
343   /* Total number of calls of any of the functions.  */
344   ++calls_total;
345
346   /* Do the real work.  */
347   result = (struct header *) (*reallocp) (real, len + sizeof (struct header));
348
349   if (result == NULL)
350     ++failed[idx_realloc];
351   else
352     {
353       /* Record whether the reduction/increase happened in place.  */
354       if (real == result)
355         ++inplace;
356       /* Was the buffer increased?  */
357       if (old_len > len)
358         ++decreasing;
359
360       /* Update the allocation data and write out the records if necessary.  */
361       update_data (result, len, old_len);
362     }
363
364   /* Return the pointer to the user buffer.  */
365   return result ? (void *) (result + 1) : NULL;
366 }
367
368
369 /* `calloc' replacement.  We keep track of the memory usage if this is the
370    correct program.  */
371 void *
372 calloc (size_t n, size_t len)
373 {
374   struct header *result;
375   size_t size = n * len;
376
377   /* Determine real implementation if not already happened.  We are
378      searching for the `malloc' implementation since it is not always
379      efficiently possible to use `calloc' because we have to add a bit
380      room to the allocation to put the header in.  */
381   if (mallocp == NULL)
382     {
383       me ();
384       mallocp = (void *(*) (size_t)) dlsym (RTLD_NEXT, "malloc");
385     }
386
387   /* If this is not the correct program just use the normal function.  */
388   if (not_me)
389     {
390       callocp = (void *(*) (size_t, size_t)) dlsym (RTLD_NEXT, "calloc");
391
392       return (*callocp) (n, len);
393     }
394
395   /* Keep track of number of calls.  */
396   ++calls[idx_calloc];
397   /* Keep track of total memory consumption for `calloc'.  */
398   total[idx_calloc] += size;
399   /* Keep track of total memory requirement.  */
400   grand_total += size;
401   /* Remember the size of the request.  */
402   if (size < 65536)
403     ++histogram[size / 16];
404   else
405     ++large;
406   /* Total number of calls of any of the functions.  */
407   ++calls_total;
408
409   /* Do the real work.  */
410   result = (struct header *) (*mallocp) (size + sizeof (struct header));
411   if (result != NULL)
412     memset (result + 1, '\0', size);
413
414   if (result == NULL)
415     ++failed[idx_calloc];
416   else
417     /* Update the allocation data and write out the records if necessary.  */
418     update_data (result, size, 0);
419
420   /* Return the pointer to the user buffer.  */
421   return result ? (void *) (result + 1) : NULL;
422 }
423
424
425 /* `free' replacement.  We keep track of the memory usage if this is the
426    correct program.  */
427 void
428 free (void *ptr)
429 {
430   struct header *real;
431
432   /* `free (NULL)' has no effect.  */
433   if (ptr == NULL)
434     {
435       ++calls[idx_free];
436       return;
437     }
438
439   /* Determine real implementation if not already happened.  */
440   if (freep == NULL)
441     {
442       me ();
443       freep = (void (*) (void *)) dlsym (RTLD_NEXT, "free");
444     }
445
446   /* If this is not the correct program just use the normal function.  */
447   if (not_me)
448     {
449       (*freep) (ptr);
450       return;
451     }
452
453   /* Determine the pointer to the header.  */
454   real = ((struct header *) ptr) - 1;
455   if (real->magic != MAGIC)
456     {
457       /* This block wasn't allocated here.  */
458       (*freep) (ptr);
459       return;
460     }
461
462   /* Keep track of number of calls.  */
463   ++calls[idx_free];
464   /* Keep track of total memory freed using `free'.  */
465   total[idx_free] += real->length;
466
467   /* Update the allocation data and write out the records if necessary.  */
468   update_data (NULL, 0, real->length);
469
470   /* Do the real work.  */
471   (*freep) (real);
472 }
473
474
475 /* Write some statistics to standard error.  */
476 static void
477 __attribute__ ((destructor))
478 dest (void)
479 {
480   int percent, cnt;
481   unsigned long int maxcalls;
482
483   /* If we haven't done anything here just return.  */
484   if (not_me)
485     return;
486   /* If we should call any of the memory functions don't do any profiling.  */
487   not_me = 1;
488
489   /* Finish the output file.  */
490   if (fd != -1)
491     {
492       /* Write the partially filled buffer.  */
493       write (fd, buffer, buffer_cnt * sizeof (struct entry));
494       /* Go back to the beginning of the file.  We allocated two records
495          here when we opened the file.  */
496       lseek (fd, 0, SEEK_SET);
497       /* Write out a record containing the total size.  */
498       first.stack = peak_total;
499       write (fd, &first, sizeof (struct entry));
500       /* Write out another record containing the maximum for heap and
501          stack.  */
502       first.heap = peak_heap;
503       first.stack = peak_stack;
504       GETTIME (first.time_low, first.time_high);
505       write (fd, &first, sizeof (struct entry));
506
507       /* Close the file.  */
508       close (fd);
509       fd = -1;
510     }
511
512   /* Write a colorful statistic.  */
513   fprintf (stderr, "\n\
514 \e[01;32mMemory usage summary:\e[0;0m heap total: %llu, heap peak: %lu, stack peak: %lu\n\
515 \e[04;34m         total calls   total memory   failed calls\e[0m\n\
516 \e[00;34m malloc|\e[0m %10lu   %12llu   %s%12lu\e[00;00m\n\
517 \e[00;34mrealloc|\e[0m %10lu   %12llu   %s%12lu\e[00;00m   (in place: %ld, dec: %ld)\n\
518 \e[00;34m calloc|\e[0m %10lu   %12llu   %s%12lu\e[00;00m\n\
519 \e[00;34m   free|\e[0m %10lu   %12llu\n",
520            grand_total, (unsigned long int) peak_heap,
521            (unsigned long int) peak_stack,
522            calls[idx_malloc], total[idx_malloc],
523            failed[idx_malloc] ? "\e[01;41m" : "", failed[idx_malloc],
524            calls[idx_realloc], total[idx_realloc],
525            failed[idx_realloc] ? "\e[01;41m" : "", failed[idx_realloc],
526            inplace, decreasing,
527            calls[idx_calloc], total[idx_calloc],
528            failed[idx_calloc] ? "\e[01;41m" : "", failed[idx_calloc],
529            calls[idx_free], total[idx_free]);
530
531   /* Write out a histoogram of the sizes of the allocations.  */
532   fprintf (stderr, "\e[01;32mHistogram for block sizes:\e[0;0m\n");
533
534   /* Determine the maximum of all calls for each size range.  */
535   maxcalls = large;
536   for (cnt = 0; cnt < 65536; cnt += 16)
537     if (histogram[cnt / 16] > maxcalls)
538       maxcalls = histogram[cnt / 16];
539
540   for (cnt = 0; cnt < 65536; cnt += 16)
541     /* Only write out the nonzero entries.  */
542     if (histogram[cnt / 16] != 0)
543       {
544         percent = (histogram[cnt / 16] * 100) / calls_total;
545         fprintf (stderr, "%5d-%-5d%12lu ", cnt, cnt + 15,
546                  histogram[cnt / 16]);
547         if (percent == 0)
548           fputs (" <1% \e[41;37m", stderr);
549         else
550           fprintf (stderr, "%3d%% \e[41;37m", percent);
551
552         /* Draw a bar with a length corresponding to the current
553            percentage.  */
554         percent = (histogram[cnt / 16] * 50) / maxcalls;
555         while (percent-- > 0)
556           fputc ('=', stderr);
557          fputs ("\e[0;0m\n", stderr);
558       }
559
560   if (large != 0)
561     {
562       percent = (large * 100) / calls_total;
563       fprintf (stderr, "   large   %12lu ", large);
564       if (percent == 0)
565         fputs (" <1% \e[41;37m", stderr);
566       else
567         fprintf (stderr, "%3d%% \e[41;37m", percent);
568       percent = (large * 50) / maxcalls;
569       while (percent-- > 0)
570         fputc ('=', stderr);
571       fputs ("\e[0;0m\n", stderr);
572     }
573 }