| /* Profile heap and stack memory usage of running program. |
| Copyright (C) 1998-2016 Free Software Foundation, Inc. |
| This file is part of the GNU C Library. |
| Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998. |
| |
| The GNU C Library is free software; you can redistribute it and/or |
| modify it under the terms of the GNU Lesser General Public |
| License as published by the Free Software Foundation; either |
| version 2.1 of the License, or (at your option) any later version. |
| |
| The GNU C Library is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| Lesser General Public License for more details. |
| |
| You should have received a copy of the GNU Lesser General Public |
| License along with the GNU C Library; if not, see |
| <http://www.gnu.org/licenses/>. */ |
| |
| #include <assert.h> |
| #include <atomic.h> |
| #include <dlfcn.h> |
| #include <errno.h> |
| #include <fcntl.h> |
| #include <inttypes.h> |
| #include <signal.h> |
| #include <stdarg.h> |
| #include <stdbool.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <unistd.h> |
| #include <stdint.h> |
| #include <sys/mman.h> |
| #include <sys/time.h> |
| |
| #include <memusage.h> |
| |
| /* Pointer to the real functions. These are determined used `dlsym' |
| when really needed. */ |
| static void *(*mallocp)(size_t); |
| static void *(*reallocp) (void *, size_t); |
| static void *(*callocp) (size_t, size_t); |
| static void (*freep) (void *); |
| |
| static void *(*mmapp) (void *, size_t, int, int, int, off_t); |
| static void *(*mmap64p) (void *, size_t, int, int, int, off64_t); |
| static int (*munmapp) (void *, size_t); |
| static void *(*mremapp) (void *, size_t, size_t, int, void *); |
| |
| enum |
| { |
| idx_malloc = 0, |
| idx_realloc, |
| idx_calloc, |
| idx_free, |
| idx_mmap_r, |
| idx_mmap_w, |
| idx_mmap_a, |
| idx_mremap, |
| idx_munmap, |
| idx_last |
| }; |
| |
| |
| struct header |
| { |
| size_t length; |
| size_t magic; |
| }; |
| |
| #define MAGIC 0xfeedbeaf |
| |
| |
| static memusage_cntr_t calls[idx_last]; |
| static memusage_cntr_t failed[idx_last]; |
| static memusage_size_t total[idx_last]; |
| static memusage_size_t grand_total; |
| static memusage_cntr_t histogram[65536 / 16]; |
| static memusage_cntr_t large; |
| static memusage_cntr_t calls_total; |
| static memusage_cntr_t inplace; |
| static memusage_cntr_t decreasing; |
| static memusage_cntr_t realloc_free; |
| static memusage_cntr_t inplace_mremap; |
| static memusage_cntr_t decreasing_mremap; |
| static memusage_size_t current_heap; |
| static memusage_size_t peak_use[3]; |
| static __thread uintptr_t start_sp; |
| |
| /* A few macros to make the source more readable. */ |
| #define peak_heap peak_use[0] |
| #define peak_stack peak_use[1] |
| #define peak_total peak_use[2] |
| |
| #define DEFAULT_BUFFER_SIZE 32768 |
| static size_t buffer_size; |
| |
| static int fd = -1; |
| |
| static bool not_me; |
| static int initialized; |
| static bool trace_mmap; |
| extern const char *__progname; |
| |
| struct entry |
| { |
| uint64_t heap; |
| uint64_t stack; |
| uint32_t time_low; |
| uint32_t time_high; |
| }; |
| |
| static struct entry buffer[2 * DEFAULT_BUFFER_SIZE]; |
| static uatomic32_t buffer_cnt; |
| static struct entry first; |
| |
| |
| /* Update the global data after a successful function call. */ |
| static void |
| update_data (struct header *result, size_t len, size_t old_len) |
| { |
| if (result != NULL) |
| { |
| /* Record the information we need and mark the block using a |
| magic number. */ |
| result->length = len; |
| result->magic = MAGIC; |
| } |
| |
| /* Compute current heap usage and compare it with the maximum value. */ |
| memusage_size_t heap |
| = catomic_exchange_and_add (¤t_heap, len - old_len) + len - old_len; |
| catomic_max (&peak_heap, heap); |
| |
| /* Compute current stack usage and compare it with the maximum |
| value. The base stack pointer might not be set if this is not |
| the main thread and it is the first call to any of these |
| functions. */ |
| if (__glibc_unlikely (!start_sp)) |
| start_sp = GETSP (); |
| |
| uintptr_t sp = GETSP (); |
| #ifdef STACK_GROWS_UPWARD |
| /* This can happen in threads where we didn't catch the thread's |
| stack early enough. */ |
| if (__glibc_unlikely (sp < start_sp)) |
| start_sp = sp; |
| size_t current_stack = sp - start_sp; |
| #else |
| /* This can happen in threads where we didn't catch the thread's |
| stack early enough. */ |
| if (__glibc_unlikely (sp > start_sp)) |
| start_sp = sp; |
| size_t current_stack = start_sp - sp; |
| #endif |
| catomic_max (&peak_stack, current_stack); |
| |
| /* Add up heap and stack usage and compare it with the maximum value. */ |
| catomic_max (&peak_total, heap + current_stack); |
| |
| /* Store the value only if we are writing to a file. */ |
| if (fd != -1) |
| { |
| uatomic32_t idx = catomic_exchange_and_add (&buffer_cnt, 1); |
| if (idx + 1 >= 2 * buffer_size) |
| { |
| /* We try to reset the counter to the correct range. If |
| this fails because of another thread increasing the |
| counter it does not matter since that thread will take |
| care of the correction. */ |
| uatomic32_t reset = (idx + 1) % (2 * buffer_size); |
| catomic_compare_and_exchange_val_acq (&buffer_cnt, reset, idx + 1); |
| if (idx >= 2 * buffer_size) |
| idx = reset - 1; |
| } |
| assert (idx < 2 * DEFAULT_BUFFER_SIZE); |
| |
| buffer[idx].heap = current_heap; |
| buffer[idx].stack = current_stack; |
| GETTIME (buffer[idx].time_low, buffer[idx].time_high); |
| |
| /* Write out buffer if it is full. */ |
| if (idx + 1 == buffer_size) |
| write (fd, buffer, buffer_size * sizeof (struct entry)); |
| else if (idx + 1 == 2 * buffer_size) |
| write (fd, &buffer[buffer_size], buffer_size * sizeof (struct entry)); |
| } |
| } |
| |
| |
| /* Interrupt handler. */ |
| static void |
| int_handler (int signo) |
| { |
| /* Nothing gets allocated. Just record the stack pointer position. */ |
| update_data (NULL, 0, 0); |
| } |
| |
| |
| /* Find out whether this is the program we are supposed to profile. |
| For this the name in the variable `__progname' must match the one |
| given in the environment variable MEMUSAGE_PROG_NAME. If the variable |
| is not present every program assumes it should be profiling. |
| |
| If this is the program open a file descriptor to the output file. |
| We will write to it whenever the buffer overflows. The name of the |
| output file is determined by the environment variable MEMUSAGE_OUTPUT. |
| |
| If the environment variable MEMUSAGE_BUFFER_SIZE is set its numerical |
| value determines the size of the internal buffer. The number gives |
| the number of elements in the buffer. By setting the number to one |
| one effectively selects unbuffered operation. |
| |
| If MEMUSAGE_NO_TIMER is not present an alarm handler is installed |
| which at the highest possible frequency records the stack pointer. */ |
| static void |
| me (void) |
| { |
| const char *env = getenv ("MEMUSAGE_PROG_NAME"); |
| size_t prog_len = strlen (__progname); |
| |
| initialized = -1; |
| mallocp = (void *(*)(size_t))dlsym (RTLD_NEXT, "malloc"); |
| reallocp = (void *(*)(void *, size_t))dlsym (RTLD_NEXT, "realloc"); |
| callocp = (void *(*)(size_t, size_t))dlsym (RTLD_NEXT, "calloc"); |
| freep = (void (*)(void *))dlsym (RTLD_NEXT, "free"); |
| |
| mmapp = (void *(*)(void *, size_t, int, int, int, off_t))dlsym (RTLD_NEXT, |
| "mmap"); |
| mmap64p = |
| (void *(*)(void *, size_t, int, int, int, off64_t))dlsym (RTLD_NEXT, |
| "mmap64"); |
| mremapp = (void *(*)(void *, size_t, size_t, int, void *))dlsym (RTLD_NEXT, |
| "mremap"); |
| munmapp = (int (*)(void *, size_t))dlsym (RTLD_NEXT, "munmap"); |
| initialized = 1; |
| |
| if (env != NULL) |
| { |
| /* Check for program name. */ |
| size_t len = strlen (env); |
| if (len > prog_len || strcmp (env, &__progname[prog_len - len]) != 0 |
| || (prog_len != len && __progname[prog_len - len - 1] != '/')) |
| not_me = true; |
| } |
| |
| /* Only open the file if it's really us. */ |
| if (!not_me && fd == -1) |
| { |
| const char *outname; |
| |
| if (!start_sp) |
| start_sp = GETSP (); |
| |
| outname = getenv ("MEMUSAGE_OUTPUT"); |
| if (outname != NULL && outname[0] != '\0' |
| && (access (outname, R_OK | W_OK) == 0 || errno == ENOENT)) |
| { |
| fd = creat64 (outname, 0666); |
| |
| if (fd == -1) |
| /* Don't do anything in future calls if we cannot write to |
| the output file. */ |
| not_me = true; |
| else |
| { |
| /* Write the first entry. */ |
| first.heap = 0; |
| first.stack = 0; |
| GETTIME (first.time_low, first.time_high); |
| /* Write it two times since we need the starting and end time. */ |
| write (fd, &first, sizeof (first)); |
| write (fd, &first, sizeof (first)); |
| |
| /* Determine the buffer size. We use the default if the |
| environment variable is not present. */ |
| buffer_size = DEFAULT_BUFFER_SIZE; |
| const char *str_buffer_size = getenv ("MEMUSAGE_BUFFER_SIZE"); |
| if (str_buffer_size != NULL) |
| { |
| buffer_size = atoi (str_buffer_size); |
| if (buffer_size == 0 || buffer_size > DEFAULT_BUFFER_SIZE) |
| buffer_size = DEFAULT_BUFFER_SIZE; |
| } |
| |
| /* Possibly enable timer-based stack pointer retrieval. */ |
| if (getenv ("MEMUSAGE_NO_TIMER") == NULL) |
| { |
| struct sigaction act; |
| |
| act.sa_handler = (sighandler_t) &int_handler; |
| act.sa_flags = SA_RESTART; |
| sigfillset (&act.sa_mask); |
| |
| if (sigaction (SIGPROF, &act, NULL) >= 0) |
| { |
| struct itimerval timer; |
| |
| timer.it_value.tv_sec = 0; |
| timer.it_value.tv_usec = 1; |
| timer.it_interval = timer.it_value; |
| setitimer (ITIMER_PROF, &timer, NULL); |
| } |
| } |
| } |
| } |
| |
| if (!not_me && getenv ("MEMUSAGE_TRACE_MMAP") != NULL) |
| trace_mmap = true; |
| } |
| } |
| |
| |
| /* Record the initial stack position. */ |
| static void |
| __attribute__ ((constructor)) |
| init (void) |
| { |
| start_sp = GETSP (); |
| if (!initialized) |
| me (); |
| } |
| |
| |
| /* `malloc' replacement. We keep track of the memory usage if this is the |
| correct program. */ |
| void * |
| malloc (size_t len) |
| { |
| struct header *result = NULL; |
| |
| /* Determine real implementation if not already happened. */ |
| if (__glibc_unlikely (initialized <= 0)) |
| { |
| if (initialized == -1) |
| return NULL; |
| |
| me (); |
| } |
| |
| /* If this is not the correct program just use the normal function. */ |
| if (not_me) |
| return (*mallocp)(len); |
| |
| /* Keep track of number of calls. */ |
| catomic_increment (&calls[idx_malloc]); |
| /* Keep track of total memory consumption for `malloc'. */ |
| catomic_add (&total[idx_malloc], len); |
| /* Keep track of total memory requirement. */ |
| catomic_add (&grand_total, len); |
| /* Remember the size of the request. */ |
| if (len < 65536) |
| catomic_increment (&histogram[len / 16]); |
| else |
| catomic_increment (&large); |
| /* Total number of calls of any of the functions. */ |
| catomic_increment (&calls_total); |
| |
| /* Do the real work. */ |
| result = (struct header *) (*mallocp)(len + sizeof (struct header)); |
| if (result == NULL) |
| { |
| catomic_increment (&failed[idx_malloc]); |
| return NULL; |
| } |
| |
| /* Update the allocation data and write out the records if necessary. */ |
| update_data (result, len, 0); |
| |
| /* Return the pointer to the user buffer. */ |
| return (void *) (result + 1); |
| } |
| |
| |
| /* `realloc' replacement. We keep track of the memory usage if this is the |
| correct program. */ |
| void * |
| realloc (void *old, size_t len) |
| { |
| struct header *result = NULL; |
| struct header *real; |
| size_t old_len; |
| |
| /* Determine real implementation if not already happened. */ |
| if (__glibc_unlikely (initialized <= 0)) |
| { |
| if (initialized == -1) |
| return NULL; |
| |
| me (); |
| } |
| |
| /* If this is not the correct program just use the normal function. */ |
| if (not_me) |
| return (*reallocp)(old, len); |
| |
| if (old == NULL) |
| { |
| /* This is really a `malloc' call. */ |
| real = NULL; |
| old_len = 0; |
| } |
| else |
| { |
| real = ((struct header *) old) - 1; |
| if (real->magic != MAGIC) |
| /* This is no memory allocated here. */ |
| return (*reallocp)(old, len); |
| |
| old_len = real->length; |
| } |
| |
| /* Keep track of number of calls. */ |
| catomic_increment (&calls[idx_realloc]); |
| if (len > old_len) |
| { |
| /* Keep track of total memory consumption for `realloc'. */ |
| catomic_add (&total[idx_realloc], len - old_len); |
| /* Keep track of total memory requirement. */ |
| catomic_add (&grand_total, len - old_len); |
| } |
| |
| if (len == 0 && old != NULL) |
| { |
| /* Special case. */ |
| catomic_increment (&realloc_free); |
| /* Keep track of total memory freed using `free'. */ |
| catomic_add (&total[idx_free], real->length); |
| |
| /* Update the allocation data and write out the records if necessary. */ |
| update_data (NULL, 0, old_len); |
| |
| /* Do the real work. */ |
| (*freep) (real); |
| |
| return NULL; |
| } |
| |
| /* Remember the size of the request. */ |
| if (len < 65536) |
| catomic_increment (&histogram[len / 16]); |
| else |
| catomic_increment (&large); |
| /* Total number of calls of any of the functions. */ |
| catomic_increment (&calls_total); |
| |
| /* Do the real work. */ |
| result = (struct header *) (*reallocp)(real, len + sizeof (struct header)); |
| if (result == NULL) |
| { |
| catomic_increment (&failed[idx_realloc]); |
| return NULL; |
| } |
| |
| /* Record whether the reduction/increase happened in place. */ |
| if (real == result) |
| catomic_increment (&inplace); |
| /* Was the buffer increased? */ |
| if (old_len > len) |
| catomic_increment (&decreasing); |
| |
| /* Update the allocation data and write out the records if necessary. */ |
| update_data (result, len, old_len); |
| |
| /* Return the pointer to the user buffer. */ |
| return (void *) (result + 1); |
| } |
| |
| |
| /* `calloc' replacement. We keep track of the memory usage if this is the |
| correct program. */ |
| void * |
| calloc (size_t n, size_t len) |
| { |
| struct header *result; |
| size_t size = n * len; |
| |
| /* Determine real implementation if not already happened. */ |
| if (__glibc_unlikely (initialized <= 0)) |
| { |
| if (initialized == -1) |
| return NULL; |
| |
| me (); |
| } |
| |
| /* If this is not the correct program just use the normal function. */ |
| if (not_me) |
| return (*callocp)(n, len); |
| |
| /* Keep track of number of calls. */ |
| catomic_increment (&calls[idx_calloc]); |
| /* Keep track of total memory consumption for `calloc'. */ |
| catomic_add (&total[idx_calloc], size); |
| /* Keep track of total memory requirement. */ |
| catomic_add (&grand_total, size); |
| /* Remember the size of the request. */ |
| if (size < 65536) |
| catomic_increment (&histogram[size / 16]); |
| else |
| catomic_increment (&large); |
| /* Total number of calls of any of the functions. */ |
| ++calls_total; |
| |
| /* Do the real work. */ |
| result = (struct header *) (*mallocp)(size + sizeof (struct header)); |
| if (result == NULL) |
| { |
| catomic_increment (&failed[idx_calloc]); |
| return NULL; |
| } |
| |
| /* Update the allocation data and write out the records if necessary. */ |
| update_data (result, size, 0); |
| |
| /* Do what `calloc' would have done and return the buffer to the caller. */ |
| return memset (result + 1, '\0', size); |
| } |
| |
| |
| /* `free' replacement. We keep track of the memory usage if this is the |
| correct program. */ |
| void |
| free (void *ptr) |
| { |
| struct header *real; |
| |
| /* Determine real implementation if not already happened. */ |
| if (__glibc_unlikely (initialized <= 0)) |
| { |
| if (initialized == -1) |
| return; |
| |
| me (); |
| } |
| |
| /* If this is not the correct program just use the normal function. */ |
| if (not_me) |
| { |
| (*freep) (ptr); |
| return; |
| } |
| |
| /* `free (NULL)' has no effect. */ |
| if (ptr == NULL) |
| { |
| catomic_increment (&calls[idx_free]); |
| return; |
| } |
| |
| /* Determine the pointer to the header. */ |
| real = ((struct header *) ptr) - 1; |
| if (real->magic != MAGIC) |
| { |
| /* This block wasn't allocated here. */ |
| (*freep) (ptr); |
| return; |
| } |
| |
| /* Keep track of number of calls. */ |
| catomic_increment (&calls[idx_free]); |
| /* Keep track of total memory freed using `free'. */ |
| catomic_add (&total[idx_free], real->length); |
| |
| /* Update the allocation data and write out the records if necessary. */ |
| update_data (NULL, 0, real->length); |
| |
| /* Do the real work. */ |
| (*freep) (real); |
| } |
| |
| |
| /* `mmap' replacement. We do not have to keep track of the size since |
| `munmap' will get it as a parameter. */ |
| void * |
| mmap (void *start, size_t len, int prot, int flags, int fd, off_t offset) |
| { |
| void *result = NULL; |
| |
| /* Determine real implementation if not already happened. */ |
| if (__glibc_unlikely (initialized <= 0)) |
| { |
| if (initialized == -1) |
| return NULL; |
| |
| me (); |
| } |
| |
| /* Always get a block. We don't need extra memory. */ |
| result = (*mmapp)(start, len, prot, flags, fd, offset); |
| |
| if (!not_me && trace_mmap) |
| { |
| int idx = (flags & MAP_ANON |
| ? idx_mmap_a : prot & PROT_WRITE ? idx_mmap_w : idx_mmap_r); |
| |
| /* Keep track of number of calls. */ |
| catomic_increment (&calls[idx]); |
| /* Keep track of total memory consumption for `malloc'. */ |
| catomic_add (&total[idx], len); |
| /* Keep track of total memory requirement. */ |
| catomic_add (&grand_total, len); |
| /* Remember the size of the request. */ |
| if (len < 65536) |
| catomic_increment (&histogram[len / 16]); |
| else |
| catomic_increment (&large); |
| /* Total number of calls of any of the functions. */ |
| catomic_increment (&calls_total); |
| |
| /* Check for failures. */ |
| if (result == NULL) |
| catomic_increment (&failed[idx]); |
| else if (idx == idx_mmap_w) |
| /* Update the allocation data and write out the records if |
| necessary. Note the first parameter is NULL which means |
| the size is not tracked. */ |
| update_data (NULL, len, 0); |
| } |
| |
| /* Return the pointer to the user buffer. */ |
| return result; |
| } |
| |
| |
| /* `mmap64' replacement. We do not have to keep track of the size since |
| `munmap' will get it as a parameter. */ |
| void * |
| mmap64 (void *start, size_t len, int prot, int flags, int fd, off64_t offset) |
| { |
| void *result = NULL; |
| |
| /* Determine real implementation if not already happened. */ |
| if (__glibc_unlikely (initialized <= 0)) |
| { |
| if (initialized == -1) |
| return NULL; |
| |
| me (); |
| } |
| |
| /* Always get a block. We don't need extra memory. */ |
| result = (*mmap64p)(start, len, prot, flags, fd, offset); |
| |
| if (!not_me && trace_mmap) |
| { |
| int idx = (flags & MAP_ANON |
| ? idx_mmap_a : prot & PROT_WRITE ? idx_mmap_w : idx_mmap_r); |
| |
| /* Keep track of number of calls. */ |
| catomic_increment (&calls[idx]); |
| /* Keep track of total memory consumption for `malloc'. */ |
| catomic_add (&total[idx], len); |
| /* Keep track of total memory requirement. */ |
| catomic_add (&grand_total, len); |
| /* Remember the size of the request. */ |
| if (len < 65536) |
| catomic_increment (&histogram[len / 16]); |
| else |
| catomic_increment (&large); |
| /* Total number of calls of any of the functions. */ |
| catomic_increment (&calls_total); |
| |
| /* Check for failures. */ |
| if (result == NULL) |
| catomic_increment (&failed[idx]); |
| else if (idx == idx_mmap_w) |
| /* Update the allocation data and write out the records if |
| necessary. Note the first parameter is NULL which means |
| the size is not tracked. */ |
| update_data (NULL, len, 0); |
| } |
| |
| /* Return the pointer to the user buffer. */ |
| return result; |
| } |
| |
| |
| /* `mremap' replacement. We do not have to keep track of the size since |
| `munmap' will get it as a parameter. */ |
| void * |
| mremap (void *start, size_t old_len, size_t len, int flags, ...) |
| { |
| void *result = NULL; |
| va_list ap; |
| |
| va_start (ap, flags); |
| void *newaddr = (flags & MREMAP_FIXED) ? va_arg (ap, void *) : NULL; |
| va_end (ap); |
| |
| /* Determine real implementation if not already happened. */ |
| if (__glibc_unlikely (initialized <= 0)) |
| { |
| if (initialized == -1) |
| return NULL; |
| |
| me (); |
| } |
| |
| /* Always get a block. We don't need extra memory. */ |
| result = (*mremapp)(start, old_len, len, flags, newaddr); |
| |
| if (!not_me && trace_mmap) |
| { |
| /* Keep track of number of calls. */ |
| catomic_increment (&calls[idx_mremap]); |
| if (len > old_len) |
| { |
| /* Keep track of total memory consumption for `malloc'. */ |
| catomic_add (&total[idx_mremap], len - old_len); |
| /* Keep track of total memory requirement. */ |
| catomic_add (&grand_total, len - old_len); |
| } |
| /* Remember the size of the request. */ |
| if (len < 65536) |
| catomic_increment (&histogram[len / 16]); |
| else |
| catomic_increment (&large); |
| /* Total number of calls of any of the functions. */ |
| catomic_increment (&calls_total); |
| |
| /* Check for failures. */ |
| if (result == NULL) |
| catomic_increment (&failed[idx_mremap]); |
| else |
| { |
| /* Record whether the reduction/increase happened in place. */ |
| if (start == result) |
| catomic_increment (&inplace_mremap); |
| /* Was the buffer increased? */ |
| if (old_len > len) |
| catomic_increment (&decreasing_mremap); |
| |
| /* Update the allocation data and write out the records if |
| necessary. Note the first parameter is NULL which means |
| the size is not tracked. */ |
| update_data (NULL, len, old_len); |
| } |
| } |
| |
| /* Return the pointer to the user buffer. */ |
| return result; |
| } |
| |
| |
| /* `munmap' replacement. */ |
| int |
| munmap (void *start, size_t len) |
| { |
| int result; |
| |
| /* Determine real implementation if not already happened. */ |
| if (__glibc_unlikely (initialized <= 0)) |
| { |
| if (initialized == -1) |
| return -1; |
| |
| me (); |
| } |
| |
| /* Do the real work. */ |
| result = (*munmapp)(start, len); |
| |
| if (!not_me && trace_mmap) |
| { |
| /* Keep track of number of calls. */ |
| catomic_increment (&calls[idx_munmap]); |
| |
| if (__glibc_likely (result == 0)) |
| { |
| /* Keep track of total memory freed using `free'. */ |
| catomic_add (&total[idx_munmap], len); |
| |
| /* Update the allocation data and write out the records if |
| necessary. */ |
| update_data (NULL, 0, len); |
| } |
| else |
| catomic_increment (&failed[idx_munmap]); |
| } |
| |
| return result; |
| } |
| |
| |
| /* Write some statistics to standard error. */ |
| static void |
| __attribute__ ((destructor)) |
| dest (void) |
| { |
| int percent, cnt; |
| unsigned long int maxcalls; |
| |
| /* If we haven't done anything here just return. */ |
| if (not_me) |
| return; |
| |
| /* If we should call any of the memory functions don't do any profiling. */ |
| not_me = true; |
| |
| /* Finish the output file. */ |
| if (fd != -1) |
| { |
| /* Write the partially filled buffer. */ |
| if (buffer_cnt > buffer_size) |
| write (fd, buffer + buffer_size, |
| (buffer_cnt - buffer_size) * sizeof (struct entry)); |
| else |
| write (fd, buffer, buffer_cnt * sizeof (struct entry)); |
| |
| /* Go back to the beginning of the file. We allocated two records |
| here when we opened the file. */ |
| lseek (fd, 0, SEEK_SET); |
| /* Write out a record containing the total size. */ |
| first.stack = peak_total; |
| write (fd, &first, sizeof (struct entry)); |
| /* Write out another record containing the maximum for heap and |
| stack. */ |
| first.heap = peak_heap; |
| first.stack = peak_stack; |
| GETTIME (first.time_low, first.time_high); |
| write (fd, &first, sizeof (struct entry)); |
| |
| /* Close the file. */ |
| close (fd); |
| fd = -1; |
| } |
| |
| /* Write a colorful statistic. */ |
| fprintf (stderr, "\n\ |
| \e[01;32mMemory usage summary:\e[0;0m heap total: %llu, heap peak: %lu, stack peak: %lu\n\ |
| \e[04;34m total calls total memory failed calls\e[0m\n\ |
| \e[00;34m malloc|\e[0m %10lu %12llu %s%12lu\e[00;00m\n\ |
| \e[00;34mrealloc|\e[0m %10lu %12llu %s%12lu\e[00;00m (nomove:%ld, dec:%ld, free:%ld)\n\ |
| \e[00;34m calloc|\e[0m %10lu %12llu %s%12lu\e[00;00m\n\ |
| \e[00;34m free|\e[0m %10lu %12llu\n", |
| (unsigned long long int) grand_total, (unsigned long int) peak_heap, |
| (unsigned long int) peak_stack, |
| (unsigned long int) calls[idx_malloc], |
| (unsigned long long int) total[idx_malloc], |
| failed[idx_malloc] ? "\e[01;41m" : "", |
| (unsigned long int) failed[idx_malloc], |
| (unsigned long int) calls[idx_realloc], |
| (unsigned long long int) total[idx_realloc], |
| failed[idx_realloc] ? "\e[01;41m" : "", |
| (unsigned long int) failed[idx_realloc], |
| (unsigned long int) inplace, |
| (unsigned long int) decreasing, |
| (unsigned long int) realloc_free, |
| (unsigned long int) calls[idx_calloc], |
| (unsigned long long int) total[idx_calloc], |
| failed[idx_calloc] ? "\e[01;41m" : "", |
| (unsigned long int) failed[idx_calloc], |
| (unsigned long int) calls[idx_free], |
| (unsigned long long int) total[idx_free]); |
| |
| if (trace_mmap) |
| fprintf (stderr, "\ |
| \e[00;34mmmap(r)|\e[0m %10lu %12llu %s%12lu\e[00;00m\n\ |
| \e[00;34mmmap(w)|\e[0m %10lu %12llu %s%12lu\e[00;00m\n\ |
| \e[00;34mmmap(a)|\e[0m %10lu %12llu %s%12lu\e[00;00m\n\ |
| \e[00;34m mremap|\e[0m %10lu %12llu %s%12lu\e[00;00m (nomove: %ld, dec:%ld)\n\ |
| \e[00;34m munmap|\e[0m %10lu %12llu %s%12lu\e[00;00m\n", |
| (unsigned long int) calls[idx_mmap_r], |
| (unsigned long long int) total[idx_mmap_r], |
| failed[idx_mmap_r] ? "\e[01;41m" : "", |
| (unsigned long int) failed[idx_mmap_r], |
| (unsigned long int) calls[idx_mmap_w], |
| (unsigned long long int) total[idx_mmap_w], |
| failed[idx_mmap_w] ? "\e[01;41m" : "", |
| (unsigned long int) failed[idx_mmap_w], |
| (unsigned long int) calls[idx_mmap_a], |
| (unsigned long long int) total[idx_mmap_a], |
| failed[idx_mmap_a] ? "\e[01;41m" : "", |
| (unsigned long int) failed[idx_mmap_a], |
| (unsigned long int) calls[idx_mremap], |
| (unsigned long long int) total[idx_mremap], |
| failed[idx_mremap] ? "\e[01;41m" : "", |
| (unsigned long int) failed[idx_mremap], |
| (unsigned long int) inplace_mremap, |
| (unsigned long int) decreasing_mremap, |
| (unsigned long int) calls[idx_munmap], |
| (unsigned long long int) total[idx_munmap], |
| failed[idx_munmap] ? "\e[01;41m" : "", |
| (unsigned long int) failed[idx_munmap]); |
| |
| /* Write out a histoogram of the sizes of the allocations. */ |
| fprintf (stderr, "\e[01;32mHistogram for block sizes:\e[0;0m\n"); |
| |
| /* Determine the maximum of all calls for each size range. */ |
| maxcalls = large; |
| for (cnt = 0; cnt < 65536; cnt += 16) |
| if (histogram[cnt / 16] > maxcalls) |
| maxcalls = histogram[cnt / 16]; |
| |
| for (cnt = 0; cnt < 65536; cnt += 16) |
| /* Only write out the nonzero entries. */ |
| if (histogram[cnt / 16] != 0) |
| { |
| percent = (histogram[cnt / 16] * 100) / calls_total; |
| fprintf (stderr, "%5d-%-5d%12lu ", cnt, cnt + 15, |
| (unsigned long int) histogram[cnt / 16]); |
| if (percent == 0) |
| fputs (" <1% \e[41;37m", stderr); |
| else |
| fprintf (stderr, "%3d%% \e[41;37m", percent); |
| |
| /* Draw a bar with a length corresponding to the current |
| percentage. */ |
| percent = (histogram[cnt / 16] * 50) / maxcalls; |
| while (percent-- > 0) |
| fputc ('=', stderr); |
| fputs ("\e[0;0m\n", stderr); |
| } |
| |
| if (large != 0) |
| { |
| percent = (large * 100) / calls_total; |
| fprintf (stderr, " large %12lu ", (unsigned long int) large); |
| if (percent == 0) |
| fputs (" <1% \e[41;37m", stderr); |
| else |
| fprintf (stderr, "%3d%% \e[41;37m", percent); |
| percent = (large * 50) / maxcalls; |
| while (percent-- > 0) |
| fputc ('=', stderr); |
| fputs ("\e[0;0m\n", stderr); |
| } |
| |
| /* Any following malloc/free etc. calls should generate statistics again, |
| because otherwise freeing something that has been malloced before |
| this destructor (including struct header in front of it) wouldn't |
| be properly freed. */ |
| not_me = false; |
| } |