OpenE2K
/
glibc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Update. 

1999-10-03  Ulrich Drepper  <drepper@cygnus.com>

	* configure.in: Accept --with-gd option and set all libgd-LDFLAGS,
	CFLAGS-memprofstat.c, and LIBGD variables.
	* config.make.in: Add LIBGD.
	* malloc/Makefile: Add rules to generate libmemprof.so and
	memprofstat.
	* malloc/memprof.c: New file.
	* malloc/memprofstat.c: New file.
This commit is contained in:
Ulrich Drepper 1999-10-04 04:37:58 +00:00
parent fcb594165e
commit c8f3e6db60
7 changed files with 1575 additions and 194 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
ChangeLog
View File

@ -1,3 +1,13 @@
1999-10-03 Ulrich Drepper <drepper@cygnus.com>
* configure.in: Accept --with-gd option and set all libgd-LDFLAGS,
CFLAGS-memprofstat.c, and LIBGD variables.
* config.make.in: Add LIBGD.
* malloc/Makefile: Add rules to generate libmemprof.so and
memprofstat.
* malloc/memprof.c: New file.
* malloc/memprofstat.c: New file.
1999-10-02 Ulrich Drepper <drepper@cygnus.com>
* resolv/nsap_addr.c (inet_nsap_addr): Little optimization.

3
config.make.in
View File

@ -86,4 +86,7 @@ KSH = @KSH@
AWK = @AWK@
PERL = @PERL@
# Additional libraries.
LIBGD = @LIBGD@
# More variables may be inserted below by configure.

500
configure vendored
View File

File diff suppressed because it is too large Load Diff

28
configure.in
View File

@ -32,6 +32,20 @@ yes)
gettext-srcdir = $withval" ;;
esac
])
# Check for a --with-gd argument and set libgd-LDFLAGS in config.make.
AC_ARG_WITH(gd, dnl
--with-gd=DIR find libgd include dir and library with prefix DIR,
[dnl
case "$with_gd" in
yes|''|no) config_vars="$config_vars
libgd-LDFLAGS =" ;;
*) config_vars="$config_vars
CFLAGS-memprofstat.c = -I$withval/include
libgd-LDFLAGS = -L$withval/lib"
libgd_include="-I$withval/include"
libgd_ldflags="-L$withval/lib" ;;
esac
])
dnl Arguments to specify presence of other packages/features.
AC_ARG_WITH(fp, dnl
@ -1083,6 +1097,20 @@ if test "$libc_cv_gcc_subtract_local_labels" = yes; then
AC_DEFINE(HAVE_SUBTRACT_LOCAL_LABELS)
fi
dnl Check whether we have the gd library available.
AC_MSG_CHECKING(for libgd)
old_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS $libgd_include"
old_LDFLAGS="$LDFLAGS"
LDFLAGS="$LDFLAGS $libgd_ldflags"
old_LIBS="$LIBS"
LIBS="$LIBS -lgd -lpng -lz"
AC_TRY_LINK([#include <gd.h>], [gdImagePng (0, 0)], LIBGD=yes, LIBGD=no)
CFLAGS="$old_CFLAGS"
LDFLAGS="$old_LDFLAGS"
LIBS="$old_LIBS"
AC_MSG_RESULT($LIBGD)
AC_SUBST(LIBGD)
### End of automated tests.
### Now run sysdeps configure fragments.

20
malloc/Makefile
View File

@ -38,6 +38,13 @@ routines = $(dist-routines) obstack
install-lib := libmcheck.a
non-lib.a := libmcheck.a
# Additional library.
extra-libs = libmemprof
extra-libs-others = $(extra-libs)
libmemprof-routines = memprof
libmemprof-inhibit-o = $(filter-out .os,$(object-suffixes))
# These should be removed by `make clean'.
extra-objs = mcheck-init.o libmcheck.a
@ -60,6 +67,19 @@ address-width=18
endif
endif
# If the gd library is available we build the `memprofstat' program.
ifneq ($(LIBGD),no)
install-bin += memprofstat
endif
# Another goal which can be used to override the configure decision.
.PHONY: do-memprofstat
do-memprofstat: $(objpfx)memprofstat
memprofstat-modules = memprofstat
$(objpfx)memprofstat: $(memprofstat-modules:%=$(objpfx)%.o)
$(LINK.o) -o $@ $^ $(libgd-LDFLAGS) -lgd -lpng -lz
include ../Rules
$(objpfx)libmcheck.a: $(objpfx)mcheck-init.o

596
malloc/memprof.c Normal file
View File

@ -0,0 +1,596 @@
/* Profile heap and stack memory usage of running program.
Copyright (C) 1998, 1999 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 Library General Public License as
published by the Free Software Foundation; either version 2 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with the GNU C Library; see the file COPYING.LIB. If not,
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include <dlfcn.h>
#include <fcntl.h>
#include <inttypes.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/time.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 *);
enum
{
idx_malloc = 0,
idx_realloc,
idx_calloc,
idx_free,
idx_last
};
struct header
{
size_t length;
size_t magic;
};
#define MAGIC 0xfeedbeaf
static unsigned long int calls[idx_last];
static unsigned long int failed[idx_last];
static unsigned long long int total[idx_last];
static unsigned long long int grand_total;
static unsigned long int histogram[65536 / 16];
static unsigned long int large;
static unsigned long int calls_total;
static unsigned long int inplace;
static unsigned long int decreasing;
static long int current_use[2];
static long int peak_use[3];
static uintptr_t start_sp;
/* A few macros to make the source more readable. */
#define current_heap current_use[0]
#define current_stack current_use[1]
#define peak_heap peak_use[0]
#define peak_stack peak_use[1]
#define peak_total peak_use[2]
#ifdef __i386__
# define GETSP() ({ register uintptr_t stack_ptr asm ("esp"); stack_ptr; })
#endif
#ifdef __alpha__
# define GETSP() ({ register uintptr_t stack_ptr asm ("$30"); stack_ptr; })
#endif
#ifdef __sparc__
# define GETSP() ({ register uintptr_t stack_ptr asm ("%sp"); stack_ptr; })
#endif
#ifdef __i386__
# define GETTIME(low,high) asm ("rdtsc" : "=a" (low), "=d" (high))
#endif
#ifndef GETTIME
# define GETTIME(low,high) \
{ \
struct timeval tval; \
uint64_t usecs; \
gettimeofday (&tval, NULL); \
usecs = (uint64_t) tval.tv_usec + (uint64_t) tval_usec * 1000000; \
low = usecs & 0xffffffff; \
high = usecs >> 32; \
}
#endif
#define DEFAULT_BUFFER_SIZE 1024
static size_t buffer_size;
static int fd = -1;
static int not_me;
extern const char *__progname;
struct entry
{
size_t heap;
size_t stack;
uint32_t time_low;
uint32_t time_high;
};
static struct entry buffer[DEFAULT_BUFFER_SIZE];
static size_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)
{
long int total_use;
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. */
current_heap += len - old_len;
if (current_heap > peak_heap)
peak_heap = current_heap;
/* Compute current stack usage and compare it with the maximum value. */
current_stack = start_sp - GETSP ();
if (current_stack > peak_stack)
peak_stack = current_stack;
/* Add up heap and stack usage and compare it with the maximum value. */
total_use = current_heap + current_stack;
if (total_use > peak_total)
peak_total = total_use;
/* Store the value only if we are writing to a file. */
if (fd != -1)
{
buffer[buffer_cnt].heap = current_heap;
buffer[buffer_cnt].stack = current_stack;
GETTIME (buffer[buffer_cnt].time_low, buffer[buffer_cnt].time_high);
++buffer_cnt;
/* Write out buffer if it is full. */
if (buffer_cnt == buffer_size)
{
write (fd, buffer, buffer_cnt * sizeof (struct entry));
buffer_cnt = 0;
}
}
}
/* Interrupt handler. */
static void
int_handler (int signo)
{
/* Nothing gets allocated. Just record the stack pointer position. */
update_data (NULL, 0, 0);
}
/* Record the initial stack position. */
static void
__attribute__ ((constructor))
init (void)
{
start_sp = GETSP ();
}
/* 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 MEMPROF_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 MEMPROF_OUTPUT.
If the environment variable MEMPROF_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 MEMPROF_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 ("MEMPROF_PROG_NAME");
size_t prog_len = strlen (__progname);
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 = 1;
}
/* Only open the file if it's really us. */
if (!not_me && fd == -1)
{
const char *outname = getenv ("MEMPROF_OUTPUT");
if (outname != NULL)
{
fd = creat (outname, 0666);
if (fd == -1)
/* Don't do anything in future calls if we cannot write to
the output file. */
not_me = 1;
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));
/* Determine the buffer size. We use the default if the
environment variable is not present. */
buffer_size = DEFAULT_BUFFER_SIZE;
if (getenv ("MEMPROF_BUFFER_SIZE") != NULL)
{
buffer_size = atoi (getenv ("MEMPROF_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 ("MEMPROF_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);
}
}
}
}
}
}
/* `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 (mallocp == NULL)
{
me ();
mallocp = (void *(*) (size_t)) dlsym (RTLD_NEXT, "malloc");
}
/* If this is not the correct program just use the normal function. */
if (not_me)
return (*mallocp) (len);
/* Keep track of number of calls. */
++calls[idx_malloc];
/* Keep track of total memory consumption for `malloc'. */
total[idx_malloc] += len;
/* Keep track of total memory requirement. */
grand_total += len;
/* Remember the size of the request. */
if (len < 65536)
++histogram[len / 16];
else
++large;
/* Total number of calls of any of the functions. */
++calls_total;
/* Do the real work. */
result = (struct header *) (*mallocp) (len + sizeof (struct header));
if (result == NULL)
++failed[idx_malloc];
else
/* Update the allocation data and write out the records if necessary. */
update_data (result, len, 0);
/* Return the pointer to the user buffer. */
return result ? (void *) (result + 1) : NULL;
}
/* `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 (reallocp == NULL)
{
me ();
reallocp = (void *(*) (void *, size_t)) dlsym (RTLD_NEXT, "realloc");
}
/* 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. */
++calls[idx_realloc];
/* Keep track of total memory consumption for `realloc'. */
total[idx_realloc] += len;
/* Keep track of total memory requirement. */
grand_total += len;
/* Remember the size of the request. */
if (len < 65536)
++histogram[len / 16];
else
++large;
/* Total number of calls of any of the functions. */
++calls_total;
/* Do the real work. */
result = (struct header *) (*reallocp) (real, len + sizeof (struct header));
if (result == NULL)
++failed[idx_realloc];
else
{
/* Record whether the reduction/increase happened in place. */
if (real == result)
++inplace;
/* Was the buffer increased? */
if (old_len > len)
++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 result ? (void *) (result + 1) : NULL;
}
/* `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. We are
searching for the `malloc' implementation since it is not always
efficiently possible to use `calloc' because we have to add a bit
room to the allocation to put the header in. */
if (mallocp == NULL)
{
me ();
mallocp = (void *(*) (size_t)) dlsym (RTLD_NEXT, "malloc");
}
/* If this is not the correct program just use the normal function. */
if (not_me)
{
callocp = (void *(*) (size_t, size_t)) dlsym (RTLD_NEXT, "calloc");
return (*callocp) (n, len);
}
/* Keep track of number of calls. */
++calls[idx_calloc];
/* Keep track of total memory consumption for `calloc'. */
total[idx_calloc] += size;
/* Keep track of total memory requirement. */
grand_total += size;
/* Remember the size of the request. */
if (size < 65536)
++histogram[size / 16];
else
++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)
memset (result + 1, '\0', size);
if (result == NULL)
++failed[idx_calloc];
else
/* Update the allocation data and write out the records if necessary. */
update_data (result, size, 0);
/* Return the pointer to the user buffer. */
return result ? (void *) (result + 1) : NULL;
}
/* `free' replacement. We keep track of the memory usage if this is the
correct program. */
void
free (void *ptr)
{
struct header *real;
/* `free (NULL)' has no effect. */
if (ptr == NULL)
{
++calls[idx_free];
return;
}
/* Determine real implementation if not already happened. */
if (freep == NULL)
{
me ();
freep = (void (*) (void *)) dlsym (RTLD_NEXT, "free");
}
/* If this is not the correct program just use the normal function. */
if (not_me)
{
(*freep) (ptr);
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. */
++calls[idx_free];
/* Keep track of total memory freed using `free'. */
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);
}
/* 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 = 1;
/* Finish the output file. */
if (fd != -1)
{
/* Write the partially filled buffer. */
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 (in place: %ld, dec: %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",
grand_total, (unsigned long int) peak_heap,
(unsigned long int) peak_stack,
calls[idx_malloc], total[idx_malloc],
failed[idx_malloc] ? "\e[01;41m" : "", failed[idx_malloc],
calls[idx_realloc], total[idx_realloc],
failed[idx_realloc] ? "\e[01;41m" : "", failed[idx_realloc],
inplace, decreasing,
calls[idx_calloc], total[idx_calloc],
failed[idx_calloc] ? "\e[01;41m" : "", failed[idx_calloc],
calls[idx_free], total[idx_free]);
/* 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,
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 ", 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);
}
}

612
malloc/memprofstat.c Normal file
View File

@ -0,0 +1,612 @@
/* Generate graphic from memory profiling data.
Copyright (C) 1998, 1999 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 Library General Public License as
published by the Free Software Foundation; either version 2 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with the GNU C Library; see the file COPYING.LIB. If not,
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include <argp.h>
#include <assert.h>
#include <errno.h>
#include <error.h>
#include <fcntl.h>
#include <getopt.h>
#include <inttypes.h>
#include <libintl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <gd.h>
#include <gdfontl.h>
#include <gdfonts.h>
/* Default size of the generated image. */
#define XSIZE 800
#define YSIZE 600
#ifndef N_
# define N_(Arg) Arg
#endif
/* Definitions of arguments for argp functions. */
static const struct argp_option options[] =
{
{ "output", 'o', "FILE", 0, N_("Name output file") },
{ "string", 's', "STRING", 0, N_("Title string used in output graphic") },
{ "time", 't', NULL, 0, N_("Generate output linear to time (default is linear to number of function calls)") },
{ "total", 'T', NULL, 0,
N_("Also draw graph for total memory consumption") },
{ "x-size", 'x', "VALUE", 0, N_("make output graphic VALUE pixel wide") },
{ "y-size", 'y', "VALUE", 0, N_("make output graphic VALUE pixel high") },
{ NULL, 0, NULL, 0, NULL }
};
/* Short description of program. */
static const char doc[] = N_("Generate graphic from memory profiling data");
/* Strings for arguments in help texts. */
static const char args_doc[] = N_("DATAFILE [OUTFILE]");
/* Prototype for option handler. */
static error_t parse_opt (int key, char *arg, struct argp_state *state);
/* Function to print some extra text in the help message. */
static char *more_help (int key, const char *text, void *input);
/* Data structure to communicate with argp functions. */
static struct argp argp =
{
options, parse_opt, args_doc, doc, NULL, more_help
};
struct entry
{
size_t heap;
size_t stack;
uint32_t time_low;
uint32_t time_high;
};
/* Size of the image. */
static size_t xsize;
static size_t ysize;
/* Name of the output file. */
static char *outname;
/* Title string for the graphic. */
static const char *string;
/* Nonzero if graph should be generated linear in time. */
static int time_based;
/* Nonzero if graph to display total use of memory should be drawn as well. */
static int also_total = 0;
int
main (int argc, char *argv[])
{
int remaining;
const char *inname;
gdImagePtr im_out;
int grey, blue, red, green, yellow, black;
int fd;
struct stat st;
size_t maxsize_heap;
size_t maxsize_stack;
size_t maxsize_total;
uint64_t total;
uint64_t cnt, cnt2;
FILE *outfile;
char buf[30];
size_t last_heap;
size_t last_stack;
size_t last_total;
struct entry headent[2];
uint64_t start_time;
uint64_t end_time;
uint64_t total_time;
outname = NULL;
xsize = XSIZE;
ysize = YSIZE;
string = NULL;
/* Parse and process arguments. */
argp_parse (&argp, argc, argv, 0, &remaining, NULL);
if (remaining >= argc || remaining + 2 < argc)
{
argp_help (&argp, stdout, ARGP_HELP_SEE | ARGP_HELP_EXIT_ERR,
program_invocation_short_name);
exit (1);
}
inname = argv[remaining++];
if (remaining < argc)
outname = argv[remaining];
else if (outname == NULL)
{
size_t len = strlen (inname);
outname = alloca (len + 5);
stpcpy (stpcpy (outname, inname), ".png");
}
/* Open for read/write since we try to repair the file in case the
application hasn't terminated cleanly. */
fd = open (inname, O_RDWR);
if (fd == -1)
error (EXIT_FAILURE, errno, "cannot open input file");
if (fstat (fd, &st) != 0)
{
close (fd);
error (EXIT_FAILURE, errno, "cannot get size of input file");
}
/* Test whether the file contains only full records. */
if ((st.st_size % sizeof (struct entry)) != 0
/* The file must at least contain the two administrative records. */
|| st.st_size < 2 * sizeof (struct entry))
{
close (fd);
error (EXIT_FAILURE, 0, "input file as incorrect size");
}
/* Compute number of data entries. */
total = st.st_size / sizeof (struct entry) - 2;
/* Read the administrative information. */
read (fd, headent, sizeof (headent));
maxsize_heap = headent[1].heap;
maxsize_stack = headent[1].stack;
maxsize_total = headent[0].stack;
if (also_total)
{
/* We use one scale and since we also draw the total amount of
memory used we have to adapt the maximum. */
maxsize_heap = maxsize_total;
maxsize_stack = maxsize_total;
}
if (maxsize_heap == 0 && maxsize_stack == 0)
{
/* The program aborted before memprof was able to write the
information about the maximum heap and stack use. Repair
the file now. */
struct entry next;
while (1)
{
if (read (fd, &next, sizeof (next)) == 0)
break;
if (next.heap > headent[1].heap)
headent[1].heap = next.heap;
if (next.stack > headent[1].stack)
headent[1].stack = next.stack;
}
headent[1].time_low = next.time_low;
headent[1].time_high = next.time_high;
/* Write the computed values in the file. */
lseek (fd, sizeof (struct entry), SEEK_SET);
write (fd, &headent[1], sizeof (struct entry));
}
start_time = ((uint64_t) headent[0].time_high) << 32 | headent[0].time_low;
end_time = ((uint64_t) headent[1].time_high) << 32 | headent[1].time_low;
total_time = end_time - start_time;
if (xsize < 100)
xsize = 100;
if (ysize < 80)
ysize = 80;
/* Create output image with the specified size. */
im_out = gdImageCreate (xsize, ysize);
/* First color allocated is background. */
grey = gdImageColorAllocate (im_out, 224, 224, 224);
/* Set transparent color. */
gdImageColorTransparent (im_out, grey);
/* These are all the other colors we need (in the moment). */
red = gdImageColorAllocate (im_out, 255, 0, 0);
green = gdImageColorAllocate (im_out, 0, 130, 0);
blue = gdImageColorAllocate (im_out, 0, 0, 255);
yellow = gdImageColorAllocate (im_out, 154, 205, 50);
black = gdImageColorAllocate (im_out, 0, 0, 0);
gdImageRectangle (im_out, 40, 20, xsize - 40, ysize - 20, blue);
gdImageString (im_out, gdFontSmall, 38, ysize - 14, (unsigned char *) "0",
blue);
gdImageString (im_out, gdFontSmall, maxsize_heap < 1024 ? 32 : 26,
ysize - 26,
(unsigned char *) (maxsize_heap < 1024 ? "0" : "0k"), red);
gdImageString (im_out, gdFontSmall, xsize - 37, ysize - 26,
(unsigned char *) (maxsize_stack < 1024 ? "0" : "0k"), green);
if (string != NULL)
gdImageString (im_out, gdFontLarge, (xsize - strlen (string) * 8) / 2,
2, (char *) string, green);
gdImageStringUp (im_out, gdFontSmall, 1, ysize / 2 - 10,
(unsigned char *) "allocated", red);
gdImageStringUp (im_out, gdFontSmall, 11, ysize / 2 - 10,
(unsigned char *) "memory", red);
gdImageStringUp (im_out, gdFontSmall, xsize - 39, ysize / 2 - 10,
(unsigned char *) "used", green);
gdImageStringUp (im_out, gdFontSmall, xsize - 27, ysize / 2 - 10,
(unsigned char *) "stack", green);
if (maxsize_heap < 1024)
{
snprintf (buf, sizeof (buf), "%Zu", maxsize_heap);
gdImageString (im_out, gdFontSmall, 39 - strlen (buf) * 6, 14, buf, red);
}
else
{
snprintf (buf, sizeof (buf), "%Zuk", maxsize_heap / 1024);
gdImageString (im_out, gdFontSmall, 39 - strlen (buf) * 6, 14, buf, red);
}
if (maxsize_stack < 1024)
{
snprintf (buf, sizeof (buf), "%Zu", maxsize_stack);
gdImageString (im_out, gdFontSmall, xsize - 37, 14, buf, green);
}
else
{
snprintf (buf, sizeof (buf), "%Zuk", maxsize_stack / 1024);
gdImageString (im_out, gdFontSmall, xsize - 37, 14, buf, green);
}
if (maxsize_heap < 1024)
{
cnt = ((ysize - 40) * (maxsize_heap / 4)) / maxsize_heap;
gdImageDashedLine (im_out, 40, ysize - 20 - cnt, xsize - 40,
ysize - 20 - cnt, red);
snprintf (buf, sizeof (buf), "%Zu", maxsize_heap / 4);
gdImageString (im_out, gdFontSmall, 39 - strlen (buf) * 6,
ysize - 26 - cnt, buf, red);
}
else
{
cnt = ((ysize - 40) * (maxsize_heap / 4096)) / (maxsize_heap / 1024);
gdImageDashedLine (im_out, 40, ysize - 20 - cnt, xsize - 40,
ysize - 20 - cnt, red);
snprintf (buf, sizeof (buf), "%Zuk", maxsize_heap / 4096);
gdImageString (im_out, gdFontSmall, 39 - strlen (buf) * 6,
ysize - 26 - cnt, buf, red);
}
if (maxsize_stack < 1024)
{
cnt2 = ((ysize - 40) * (maxsize_stack / 4)) / maxsize_stack;
if (cnt != cnt2)
gdImageDashedLine (im_out, 40, ysize - 20 - cnt2, xsize - 40,
ysize - 20 - cnt2, green);
snprintf (buf, sizeof (buf), "%Zu", maxsize_stack / 4);
gdImageString (im_out, gdFontSmall, xsize - 37, ysize - 26 - cnt2,
buf, green);
}
else
{
cnt2 = ((ysize - 40) * (maxsize_stack / 4096)) / (maxsize_stack / 1024);
if (cnt != cnt2)
gdImageDashedLine (im_out, 40, ysize - 20 - cnt2, xsize - 40,
ysize - 20 - cnt2, green);
snprintf (buf, sizeof (buf), "%Zuk", maxsize_stack / 4096);
gdImageString (im_out, gdFontSmall, xsize - 37, ysize - 26 - cnt2,
buf, green);
}
if (maxsize_heap < 1024)
{
cnt = ((ysize - 40) * (maxsize_heap / 2)) / maxsize_heap;
gdImageDashedLine (im_out, 40, ysize - 20 - cnt, xsize - 40,
ysize - 20 - cnt, red);
snprintf (buf, sizeof (buf), "%Zu", maxsize_heap / 2);
gdImageString (im_out, gdFontSmall, 39 - strlen (buf) * 6,
ysize - 26 - cnt, buf, red);
}
else
{
cnt = ((ysize - 40) * (maxsize_heap / 2048)) / (maxsize_heap / 1024);
gdImageDashedLine (im_out, 40, ysize - 20 - cnt, xsize - 40,
ysize - 20 - cnt, red);
snprintf (buf, sizeof (buf), "%Zuk", maxsize_heap / 2048);
gdImageString (im_out, gdFontSmall, 39 - strlen (buf) * 6,
ysize - 26 - cnt, buf, red);
}
if (maxsize_stack < 1024)
{
cnt2 = ((ysize - 40) * (maxsize_stack / 2)) / maxsize_stack;
if (cnt != cnt2)
gdImageDashedLine (im_out, 40, ysize - 20 - cnt2, xsize - 40,
ysize - 20 - cnt2, green);
snprintf (buf, sizeof (buf), "%Zu", maxsize_stack / 2);
gdImageString (im_out, gdFontSmall, xsize - 37, ysize - 26 - cnt2,
buf, green);
}
else
{
cnt2 = ((ysize - 40) * (maxsize_stack / 2048)) / (maxsize_stack / 1024);
if (cnt != cnt2)
gdImageDashedLine (im_out, 40, ysize - 20 - cnt2, xsize - 40,
ysize - 20 - cnt2, green);
snprintf (buf, sizeof (buf), "%Zuk", maxsize_stack / 2048);
gdImageString (im_out, gdFontSmall, xsize - 37, ysize - 26 - cnt2,
buf, green);
}
if (maxsize_heap < 1024)
{
cnt = ((ysize - 40) * ((3 * maxsize_heap) / 4)) / maxsize_heap;
gdImageDashedLine (im_out, 40, ysize - 20 - cnt, xsize - 40,
ysize - 20 - cnt, red);
snprintf (buf, sizeof (buf), "%Zu", (3 * maxsize_heap) / 4);
gdImageString (im_out, gdFontSmall, 39 - strlen (buf) * 6,
ysize - 26 - cnt, buf, red);
}
else
{
cnt = ((ysize - 40) * ((3 * maxsize_heap) / 4096)) / (maxsize_heap
/ 1024);
gdImageDashedLine (im_out, 40, ysize - 20 - cnt, xsize - 40,
ysize - 20 - cnt, red);
snprintf (buf, sizeof (buf), "%Zuk", (3 * maxsize_heap) / 4096);
gdImageString (im_out, gdFontSmall, 39 - strlen (buf) * 6,
ysize - 26 - cnt, buf, red);
}
if (maxsize_stack < 1024)
{
cnt2 = ((ysize - 40) * ((3 * maxsize_stack) / 4)) / maxsize_stack;
if (cnt != cnt2)
gdImageDashedLine (im_out, 40, ysize - 20 - cnt2, xsize - 40,
ysize - 20 - cnt2, green);
snprintf (buf, sizeof (buf), "%Zu", (3 * maxsize_stack) / 4);
gdImageString (im_out, gdFontSmall, xsize - 37, ysize - 26 - cnt2,
buf, green);
}
else
{
cnt2 = (((ysize - 40) * ((3 * maxsize_stack) / 4096))
/ (maxsize_stack / 1024));
if (cnt != cnt2)
gdImageDashedLine (im_out, 40, ysize - 20 - cnt2, xsize - 40,
ysize - 20 - cnt2, green);
snprintf (buf, sizeof (buf), "%Zuk", (3 * maxsize_stack) / 4096);
gdImageString (im_out, gdFontSmall, xsize - 37, ysize - 26 - cnt2,
buf, green);
}
snprintf (buf, sizeof (buf), "%llu", total);
gdImageString (im_out, gdFontSmall, xsize - 50, ysize - 14, buf, blue);
if (!time_based)
{
uint64_t previously = start_time;
gdImageString (im_out, gdFontSmall, 40 + (xsize - 32 * 6 - 80) / 2,
ysize - 12,
(unsigned char *) "# memory handling function calls",
blue);
last_stack = last_heap = last_total = ysize - 20;
for (cnt = 1; cnt <= total; ++cnt)
{
struct entry entry;
size_t new[2];
uint64_t now;
read (fd, &entry, sizeof (entry));
now = ((uint64_t) entry.time_high) << 32 | entry.time_low;
if ((((previously - start_time) * 100) / total_time) % 10 < 5)
gdImageFilledRectangle (im_out,
40 + ((cnt - 1) * (xsize - 80)) / total,
ysize - 19,
39 + (cnt * (xsize - 80)) / total,
ysize - 14, yellow);
previously = now;
if (also_total)
{
size_t new3;
new3 = (ysize - 20) - ((((unsigned long long int) (ysize - 40))
* (entry.heap + entry.stack))
/ maxsize_heap);
gdImageLine (im_out, 40 + ((xsize - 80) * (cnt - 1)) / total,
last_total,
40 + ((xsize - 80) * cnt) / total, new3,
black);
last_total = new3;
}
// assert (entry.heap <= maxsize_heap);
new[0] = (ysize - 20) - ((((unsigned long long int) (ysize - 40))
* entry.heap) / maxsize_heap);
gdImageLine (im_out, 40 + ((xsize - 80) * (cnt - 1)) / total,
last_heap, 40 + ((xsize - 80) * cnt) / total, new[0],
red);
last_heap = new[0];
// assert (entry.stack <= maxsize_stack);
new[1] = (ysize - 20) - ((((unsigned long long int) (ysize - 40))
* entry.stack) / maxsize_stack);
gdImageLine (im_out, 40 + ((xsize - 80) * (cnt - 1)) / total,
last_stack, 40 + ((xsize - 80) * cnt) / total, new[1],
green);
last_stack = new[1];
}
cnt = 0;
while (cnt < total)
{
gdImageLine (im_out, 40 + ((xsize - 80) * cnt) / total, ysize - 20,
40 + ((xsize - 80) * cnt) / total, ysize - 15, blue);
cnt += MAX (1, total / 20);
}
gdImageLine (im_out, xsize - 40, ysize - 20, xsize - 40, ysize - 15,
blue);
}
else
{
uint64_t next_tick = MAX (1, total / 20);
size_t last_xpos = 40;
gdImageString (im_out, gdFontSmall, 40 + (xsize - 39 * 6 - 80) / 2,
ysize - 12,
(unsigned char *) "\
# memory handling function calls / time", blue);
for (cnt = 0; cnt < 20; cnt += 2)
gdImageFilledRectangle (im_out,
40 + (cnt * (xsize - 80)) / 20, ysize - 19,
39 + ((cnt + 1) * (xsize - 80)) / 20,
ysize - 14, yellow);
last_stack = last_heap = last_total = ysize - 20;
for (cnt = 1; cnt <= total; ++cnt)
{
struct entry entry;
size_t new[2];
size_t xpos;
uint64_t now;
read (fd, &entry, sizeof (entry));
now = ((uint64_t) entry.time_high) << 32 | entry.time_low;
xpos = 40 + ((xsize - 80) * (now - start_time)) / total_time;
if (cnt == next_tick)
{
gdImageLine (im_out, xpos, ysize - 20, xpos, ysize - 15, blue);
next_tick += MAX (1, total / 20);
}
if (also_total)
{
size_t new3;
new3 = (ysize - 20) - ((((unsigned long long int) (ysize - 40))
* (entry.heap + entry.stack))
/ maxsize_heap);
gdImageLine (im_out, last_xpos, last_total, xpos, new3, black);
last_total = new3;
}
new[0] = (ysize - 20) - ((((unsigned long long int) (ysize - 40))
* entry.heap) / maxsize_heap);
gdImageLine (im_out, last_xpos, last_heap, xpos, new[0], red);
last_heap = new[0];
// assert (entry.stack <= maxsize_stack);
new[1] = (ysize - 20) - ((((unsigned long long int) (ysize - 40))
* entry.stack) / maxsize_stack);
gdImageLine (im_out, last_xpos, last_stack, xpos, new[1], green);
last_stack = new[1];
last_xpos = xpos;
}
}
/* Write out the result. */
outfile = fopen (outname, "w");
if (outfile == NULL)
error (EXIT_FAILURE, errno, "cannot open output file");
gdImagePng (im_out, outfile);
fclose (outfile);
gdImageDestroy (im_out);
exit (0);
}
/* Handle program arguments. */
static error_t
parse_opt (int key, char *arg, struct argp_state *state)
{
switch (key)
{
case 'o':
outname = arg;
break;
case 's':
string = arg;
break;
case 't':
time_based = 1;
break;
case 'T':
also_total = 1;
break;
case 'x':
xsize = atoi (arg);
if (xsize == 0)
xsize = XSIZE;
break;
case 'y':
ysize = atoi (arg);
if (ysize == 0)
ysize = XSIZE;
break;
default:
return ARGP_ERR_UNKNOWN;
}
return 0;
}
static char *
more_help (int key, const char *text, void *input)
{
char *orig;
char *cp;
switch (key)
{
case ARGP_KEY_HELP_EXTRA:
/* We print some extra information. */
orig = gettext ("\
Report bugs using the `glibcbug' script to <bugs@gnu.org>.\n");
cp = strdup (orig);
if (cp == NULL)
cp = orig;
return cp;
default:
break;
}
return (char *) text;
}