From 63abb1e790d634cba4162c2997f2ae330d63b703 Mon Sep 17 00:00:00 2001 From: Fred Fish Date: Sun, 15 Mar 1992 02:16:01 +0000 Subject: New memory malloc malloc library, based on GNU malloc. --- mmalloc/mrealloc.c | 151 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 151 insertions(+) create mode 100644 mmalloc/mrealloc.c (limited to 'mmalloc/mrealloc.c') diff --git a/mmalloc/mrealloc.c b/mmalloc/mrealloc.c new file mode 100644 index 0000000..83c8996 --- /dev/null +++ b/mmalloc/mrealloc.c @@ -0,0 +1,151 @@ +/* Change the size of a block allocated by `mmalloc'. + Copyright 1990, 1991 Free Software Foundation + Written May 1989 by Mike Haertel. + +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., 675 Mass Ave, +Cambridge, MA 02139, USA. + + The author may be reached (Email) at the address mike@ai.mit.edu, + or (US mail) as Mike Haertel c/o Free Software Foundation. */ + +#include "mmalloc.h" + +/* Resize the given region to the new size, returning a pointer + to the (possibly moved) region. This is optimized for speed; + some benchmarks seem to indicate that greater compactness is + achieved by unconditionally allocating and copying to a + new region. This module has incestuous knowledge of the + internals of both mfree and mmalloc. */ + +PTR +mrealloc (md, ptr, size) + PTR md; + PTR ptr; + size_t size; +{ + struct mdesc *mdp; + PTR result; + int type; + size_t block, blocks, oldlimit; + + if (size == 0) + { + mfree (md, ptr); + return (mmalloc (md, 0)); + } + else if (ptr == NULL) + return (mmalloc (md, size)); + + mdp = MD_TO_MDP (md); + + if (mdp -> mrealloc_hook != NULL) + { + return ((*mdp -> mrealloc_hook) (md, ptr, size)); + } + + block = BLOCK(ptr); + + type = mdp -> heapinfo[block].busy.type; + switch (type) + { + case 0: + /* Maybe reallocate a large block to a small fragment. */ + if (size <= BLOCKSIZE / 2) + { + result = mmalloc (md, size); + if (result != NULL) + { + memcpy (result, ptr, size); + mfree (md, ptr); + return (result); + } + } + + /* The new size is a large allocation as well; + see if we can hold it in place. */ + blocks = BLOCKIFY(size); + if (blocks < mdp -> heapinfo[block].busy.info.size) + { + /* The new size is smaller; return + excess memory to the free list. */ + mdp -> heapinfo[block + blocks].busy.type = 0; + mdp -> heapinfo[block + blocks].busy.info.size + = mdp -> heapinfo[block].busy.info.size - blocks; + mdp -> heapinfo[block].busy.info.size = blocks; + mfree (md, ADDRESS(block + blocks)); + result = ptr; + } + else if (blocks == mdp -> heapinfo[block].busy.info.size) + /* No size change necessary. */ + result = ptr; + else + { + /* Won't fit, so allocate a new region that will. + Free the old region first in case there is sufficient + adjacent free space to grow without moving. */ + blocks = mdp -> heapinfo[block].busy.info.size; + /* Prevent free from actually returning memory to the system. */ + oldlimit = mdp -> heaplimit; + mdp -> heaplimit = 0; + mfree (md, ptr); + mdp -> heaplimit = oldlimit; + result = mmalloc (md, size); + if (result == NULL) + { + (void) mmalloc (md, blocks * BLOCKSIZE); + return NULL; + } + if (ptr != result) + memmove (result, ptr, blocks * BLOCKSIZE); + } + break; + + default: + /* Old size is a fragment; type is logarithm + to base two of the fragment size. */ + if (size > (size_t) (1 << (type - 1)) && size <= (size_t) (1 << type)) + /* The new size is the same kind of fragment. */ + result = ptr; + else + { + /* The new size is different; allocate a new space, + and copy the lesser of the new size and the old. */ + result = mmalloc (md, size); + if (result == NULL) + return (NULL); + memcpy (result, ptr, MIN(size, (size_t) 1 << type)); + mfree (md, ptr); + } + break; + } + + return (result); +} + +/* When using this package, provide a version of malloc/realloc/free built + on top of it, so that if we use the default sbrk() region we will not + collide with another malloc package trying to do the same thing, if + the application contains any "hidden" calls to malloc/realloc/free (such + as inside a system library). + + NOTE: Defining our own copy of this breaks ANSI conformance. */ + +PTR +realloc (ptr, size) + PTR ptr; + size_t size; +{ + return (mrealloc ((void *) NULL, ptr, size)); +} -- cgit v1.1