This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 1, or (at your option)
+ the Free Software Foundation; either version 2, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA.
In other words, you are welcome to use, share and improve this program.
You are forbidden to forbid anyone else to use, share and improve
# endif /* HAVE_BCOPY */
#endif /* !__GNUC__ */
+/* Generic pointer type. */
+#ifndef PTR_T
+# if defined (__STDC__)
+# define PTR_T void *
+# else
+# define PTR_T char *
+# endif
+#endif
+
#if !defined (NULL)
# define NULL 0
#endif
* (whether by morecore() or for alignment); TSBRK is the total number of
* bytes requested from the kernel with sbrk(). BYTESUSED is the total
* number of bytes consumed by blocks currently in use; BYTESFREE is the
- * total number of bytes currently on all of the free lists. NBSPLIT is
+ * total number of bytes currently on all of the free lists. TBSPLIT is
* the number of times a larger block was split to satisfy a smaller request.
- * NBCOALESCE is the number of times two adjacent smaller blocks off the free
+ * NSPLIT[i] is the number of times a block of size I was split.
+ * TBCOALESCE is the number of times two adjacent smaller blocks off the free
* list were combined to satisfy a larger request.
*/
struct _malstats {
int nrcopy;
int nrecurse;
int nsbrk;
- int32_t tsbrk;
- int32_t bytesused;
- int32_t bytesfree;
- int nbsplit;
- int nbcoalesce;
+ bits32_t tsbrk;
+ bits32_t bytesused;
+ bits32_t bytesfree;
+ int tbsplit;
+ int nsplit[NBUCKETS];
+ int tbcoalesce;
};
static struct _malstats _mstats;
NFREE is the number of free blocks for this allocation size. NUSED
is the number of blocks in use. NMAL is the number of requests for
blocks of size BLOCKSIZE. NMORECORE is the number of times we had
- to call MORECORE to repopulate the free list for this bucket. */
+ to call MORECORE to repopulate the free list for this bucket. NSPLIT
+ is the number of times a block of this size was split to satisfy a
+ smaller request. */
struct bucket_stats {
- u_int32_t blocksize;
+ u_bits32_t blocksize;
int nfree;
int nused;
int nmal;
int nmorecore;
+ int nsplit;
};
#endif /* MALLOC_STATS */
char mi_alloc; /* ISALLOC or ISFREE */ /* 1 */
char mi_index; /* index in nextf[] */ /* 1 */
/* Remainder are valid only when block is allocated */
- u_int32_t mi_nbytes; /* # of bytes allocated */ /* 4 */
- unsigned short mi_magic2;/* should be == MAGIC2 */ /* 2 */
+ u_bits32_t mi_nbytes; /* # of bytes allocated */ /* 4 */
+ u_bits16_t mi_magic2;/* should be == MAGIC2 */ /* 2 */
} minfo;
};
#define mh_alloc minfo.mi_alloc
/* Minimum and maximum bucket indices for block splitting (and to bound
the search for a block to split). */
#define SPLIT_MIN 3
-#define SPLIT_MID 9
-#define SPLIT_MAX 12
+#define SPLIT_MID 11 /* XXX - was 9 */
+#define SPLIT_MAX 14 /* XXX - was 12 */
/* Minimum and maximum bucket indices for block coalescing. */
#define COMBINE_MIN 6
static int pagesz; /* system page size. */
static int pagebucket; /* bucket for requests a page in size */
+static int maxbuck; /* highest bucket receiving allocation request. */
+
+#ifdef SHELL
+extern int interrupt_immediately;
+extern int signal_is_trapped ();
+#endif
#if 0
/* Coalesce two adjacent free blocks off the free list for size NU - 1,
return; /* not adjacent */
#ifdef MALLOC_STATS
- _mstats.nbcoalesce++;
+ _mstats.tbcoalesce++;
#endif
/* Since they are adjacent, remove them from the free list */
register int nu;
{
register union mhead *mp;
- int nbuck, nblks;
+ int nbuck, nblks, split_max;
unsigned long siz;
+ split_max = (maxbuck > SPLIT_MAX) ? maxbuck : SPLIT_MAX;
+
if (nu >= SPLIT_MID)
{
- for (nbuck = SPLIT_MAX; nbuck > nu; nbuck--)
+ for (nbuck = split_max; nbuck > nu; nbuck--)
{
if (busy[nbuck] || nextf[nbuck] == 0)
continue;
}
else
{
- for (nbuck = nu + 1; nbuck <= SPLIT_MAX; nbuck++)
+ for (nbuck = nu + 1; nbuck <= split_max; nbuck++)
{
if (busy[nbuck] || nextf[nbuck] == 0)
continue;
}
}
- if (nbuck > SPLIT_MAX || nbuck <= nu)
+ if (nbuck > split_max || nbuck <= nu)
return;
/* XXX might want to split only if nextf[nbuck] has >= 2 blocks free
and nbuck is below some threshold. */
#ifdef MALLOC_STATS
- _mstats.nbsplit++;
+ _mstats.tbsplit++;
+ _mstats.nsplit[nbuck]++;
#endif
/* Figure out how many blocks we'll get. */
}
static void
+block_signals (setp, osetp)
+ sigset_t *setp, *osetp;
+{
+#ifdef HAVE_POSIX_SIGNALS
+ sigfillset (setp);
+ sigemptyset (osetp);
+ sigprocmask (SIG_BLOCK, setp, osetp);
+#else
+# if defined (HAVE_BSD_SIGNALS)
+ *osetp = sigsetmask (-1);
+# endif
+#endif
+}
+
+static void
+unblock_signals (setp, osetp)
+ sigset_t *setp, *osetp;
+{
+#ifdef HAVE_POSIX_SIGNALS
+ sigprocmask (SIG_SETMASK, osetp, (sigset_t *)NULL);
+#else
+# if defined (HAVE_BSD_SIGNALS)
+ sigsetmask (*osetp);
+# endif
+#endif
+}
+
+static void
morecore (nu) /* ask system for more memory */
register int nu; /* size index to get more of */
{
register int nblks;
register long siz;
long sbrk_amt; /* amount to get via sbrk() */
+ sigset_t set, oset;
+ int blocked_sigs;
/* Block all signals in case we are executed from a signal handler. */
-#if defined (HAVE_BSD_SIGNALS)
- int oldmask;
- oldmask = sigsetmask (-1);
-#else
-# if defined (HAVE_POSIX_SIGNALS)
- sigset_t set, oset;
- sigfillset (&set);
- sigemptyset (&oset);
- sigprocmask (SIG_BLOCK, &set, &oset);
-# endif /* HAVE_POSIX_SIGNALS */
-#endif /* HAVE_BSD_SIGNALS */
+ blocked_sigs = 0;
+#ifdef SHELL
+ if (interrupt_immediately || signal_is_trapped (SIGINT) || signal_is_trapped (SIGCHLD))
+#endif
+ {
+ block_signals (&set, &oset);
+ blocked_sigs = 1;
+ }
siz = 1 << (nu + 3); /* size of desired block for nextf[nu] */
if (siz < 0)
- return; /* oops */
+ goto morecore_done; /* oops */
#ifdef MALLOC_STATS
_mstats.nmorecore[nu]++;
/* Try to split a larger block here, if we're within the range of sizes
to split. */
+#if 0
if (nu >= SPLIT_MIN && nu < SPLIT_MAX)
+#else
+ if (nu >= SPLIT_MIN)
+#endif
{
bsplit (nu);
if (nextf[nu] != 0)
{
bcoalesce (nu);
if (nextf[nu] != 0)
- goto morecore_done;
+ goto morecore_done;
}
#endif
/* Totally out of memory. */
if ((long)mp == -1)
- return;
+ goto morecore_done;
/* shouldn't happen, but just in case -- require 8-byte alignment */
if ((long)mp & 7)
CHAIN (mp) = 0;
morecore_done:
-#if defined (HAVE_BSD_SIGNALS)
- sigsetmask (oldmask);
-#else
-# if defined (HAVE_POSIX_SIGNALS)
- sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
-# else
- ; /* nothing to do, but need a null statement before the brace */
-# endif
-#endif /* HAVE_BSD_SIGNALS */
+ if (blocked_sigs)
+ unblock_signals (&set, &oset);
}
#if defined (MEMSCRAMBLE) || !defined (NO_CALLOC)
static void
malloc_debug_dummy ()
{
- ;
+ write (1, "malloc_debug_dummy\n", 19);
}
-char *
+PTR_T
malloc (n) /* get a block */
size_t n;
{
pagesz = getpagesize ();
if (pagesz < 1024)
- pagesz = 1024;
+ pagesz = 1024;
/* OK, how much do we need to allocate to make things page-aligned?
- This partial page is wasted space. Once we figure out how much
- to advance the break pointer, go ahead and do it. */
+ This partial page is wasted space. Once we figure out how much
+ to advance the break pointer, go ahead and do it. */
sbrk_needed = pagesz - ((long)sbrk (0) & (pagesz - 1)); /* sbrk(0) % pagesz */
if (sbrk_needed < 0)
- sbrk_needed += pagesz;
+ sbrk_needed += pagesz;
/* Now allocate the wasted space. */
if (sbrk_needed)
- {
+ {
#ifdef MALLOC_STATS
_mstats.nsbrk++;
_mstats.tsbrk += sbrk_needed;
#endif
- if ((long)sbrk (sbrk_needed) == -1)
- return (NULL);
- }
+ if ((long)sbrk (sbrk_needed) == -1)
+ return (NULL);
+ }
nunits = 0;
nbytes = 8;
while (pagesz > nbytes)
- {
- nbytes <<= 1;
- nunits++;
- }
+ {
+ nbytes <<= 1;
+ nunits++;
+ }
pagebucket = nunits;
}
}
else
{
- register u_int32_t amt;
+ register u_bits32_t amt;
nunits = pagebucket;
amt = pagesz;
while (nbytes > amt)
- {
- amt <<= 1;
- nunits++;
- }
+ {
+ amt <<= 1;
+ nunits++;
+ }
}
/* In case this is reentrant use of malloc from signal handler,
while (busy[nunits]) nunits++;
busy[nunits] = 1;
+ if (nunits > maxbuck)
+ maxbuck = nunits;
+
/* If there are no blocks of the appropriate size, go get some */
if (nextf[nunits] == 0)
morecore (nunits);
_mstats.tmalloc[nunits]++;
_mstats.nmal++;
#endif /* MALLOC_STATS */
- return (char *) (p + 1);
+ return (char *) (p + 1); /* XXX - should be cast to PTR_T? */
}
void
free (mem)
- char *mem;
+ PTR_T mem;
{
register union mhead *p;
register char *ap;
register int nunits;
- if ((ap = mem) == 0)
+ if ((ap = (char *)mem) == 0)
return;
p = (union mhead *) ap - 1;
ASSERT (nunits < NBUCKETS);
p->mh_alloc = ISFREE;
+#if 0
+ if (busy[nunits] == 1)
+ botch ("calling free %d while in malloc for %d", nunits, nunits);
+#endif
+
/* Protect against signal handlers calling malloc. */
busy[nunits] = 1;
/* Put this block on the free list. */
#endif /* MALLOC_STATS */
}
-char *
+PTR_T
realloc (mem, n)
- char *mem;
+ PTR_T mem;
register size_t n;
{
register union mhead *p;
- register u_int32_t tocopy;
+ register u_bits32_t tocopy;
register unsigned int nbytes;
register int nunits;
register char *m;
ASSERT (p->mh_alloc == ISALLOC);
ASSERT (p->mh_magic2 == MAGIC2);
- m = mem + (tocopy = p->mh_nbytes);
+ m = (char *)mem + (tocopy = p->mh_nbytes);
ASSERT (*m++ == MAGIC1); ASSERT (*m++ == MAGIC1);
ASSERT (*m++ == MAGIC1); ASSERT (*m == MAGIC1);
/* If ok, use the same block, just marking its size as changed. */
if (nbytes > (4 << nunits) && nbytes <= (8 << nunits))
{
- m = mem + tocopy;
+ m = (char *)mem + tocopy;
*m++ = 0; *m++ = 0; *m++ = 0; *m++ = 0;
p->mh_nbytes = n;
- m = mem + n;
+ m = (char *)mem + n;
*m++ = MAGIC1; *m++ = MAGIC1; *m++ = MAGIC1; *m++ = MAGIC1;
return mem;
}
return m;
}
-char *
+PTR_T
memalign (alignment, size)
unsigned int alignment;
size_t size;
#if !defined (HPUX)
/* This runs into trouble with getpagesize on HPUX, and Multimax machines.
Patching out seems cleaner than the ugly fix needed. */
-#if defined (__STDC__)
-void *
-#else
-char *
-#endif
+PTR_T
valloc (size)
size_t size;
{
#endif /* !HPUX */
#ifndef NO_CALLOC
-char *
+PTR_T
calloc (n, s)
size_t n, s;
{
void
cfree (p)
- char *p;
+ PTR_T p;
{
free (p);
}
if (size < 0 || size >= NBUCKETS)
{
v.blocksize = 0;
- v.nused = v.nmal = 0;
+ v.nused = v.nmal = v.nmorecore = v.nsplit = 0;
return v;
}
v.nused = _mstats.nmalloc[size];
v.nmal = _mstats.tmalloc[size];
v.nmorecore = _mstats.nmorecore[size];
+ v.nsplit = _mstats.nsplit[size];
for (p = nextf[size]; p; p = CHAIN (p))
v.nfree++;
return (result);
}
-void
-print_malloc_stats (s)
+static void
+_print_malloc_stats (s, fp)
char *s;
+ FILE *fp;
{
register int i;
int totused, totfree;
struct bucket_stats v;
- fprintf (stderr, "Memory allocation statistics: %s\n\tsize\tfree\tin use\ttotal\tmorecore\n", s ? s : "");
+ fprintf (fp, "Memory allocation statistics: %s\n\tsize\tfree\tin use\ttotal\tmorecore\tsplit\n", s ? s : "");
for (i = totused = totfree = 0; i < NBUCKETS; i++)
{
v = malloc_bucket_stats (i);
- fprintf (stderr, "%12lu\t%4d\t%6d\t%5d\t%8d\n", v.blocksize, v.nfree, v.nused, v.nmal, v.nmorecore);
+ fprintf (fp, "%12lu\t%4d\t%6d\t%5d\t%8d\t%5d\n", v.blocksize, v.nfree, v.nused, v.nmal, v.nmorecore, v.nsplit);
totfree += v.nfree * v.blocksize;
totused += v.nused * v.blocksize;
}
- fprintf (stderr, "\nTotal bytes in use: %d, total bytes free: %d\n",
+ fprintf (fp, "\nTotal bytes in use: %d, total bytes free: %d\n",
totused, totfree);
- fprintf (stderr, "Total mallocs: %d, total frees: %d, total reallocs: %d (%d copies)\n",
+ fprintf (fp, "Total mallocs: %d, total frees: %d, total reallocs: %d (%d copies)\n",
_mstats.nmal, _mstats.nfre, _mstats.nrealloc, _mstats.nrcopy);
- fprintf (stderr, "Total sbrks: %d, total bytes via sbrk: %d\n",
+ fprintf (fp, "Total sbrks: %d, total bytes via sbrk: %d\n",
_mstats.nsbrk, _mstats.tsbrk);
- fprintf (stderr, "Total blocks split: %d, total block coalesces: %d\n",
- _mstats.nbsplit, _mstats.nbcoalesce);
+ fprintf (fp, "Total blocks split: %d, total block coalesces: %d\n",
+ _mstats.tbsplit, _mstats.tbcoalesce);
+}
+
+void
+print_malloc_stats (s)
+ char *s;
+{
+ _print_malloc_stats (s, stderr);
+}
+
+#define TRACEROOT "/var/tmp/maltrace/trace."
+extern char *inttostr ();
+
+void
+trace_malloc_stats (s)
+ char *s;
+{
+ char ibuf[32], *ip;
+ char fname[64];
+ int p;
+ FILE *fp;
+
+ p = (int)getpid();
+ ip = inttostr(p, ibuf, sizeof(ibuf));
+ strcpy (fname, TRACEROOT);
+ strcat (fname, ip);
+ fp = fopen(fname, "w");
+ if (fp)
+ {
+ _print_malloc_stats (s, fp);
+ fflush(fp);
+ fclose(fp);
+ }
}
#endif /* MALLOC_STATS */
projects / platform / upstream / bash.git / blobdiff