From 35d29fcb08fadaf006561a058746b0fce76a6a74 Mon Sep 17 00:00:00 2001 From: Eric Andersen Date: Thu, 18 Jul 2002 15:00:07 +0000 Subject: Miles Bader implemented a new mmap based malloc which is much smarter than the old "malloc-simple", and actually works, unlike the old "malloc". So kill the old "malloc-simple" and the old "malloc" and replace them with Miles' new malloc implementation. Update Config files to match. Thanks Miles! --- libc/stdlib/malloc/heap_free.c | 127 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 127 insertions(+) create mode 100644 libc/stdlib/malloc/heap_free.c (limited to 'libc/stdlib/malloc/heap_free.c') diff --git a/libc/stdlib/malloc/heap_free.c b/libc/stdlib/malloc/heap_free.c new file mode 100644 index 000000000..20ef65572 --- /dev/null +++ b/libc/stdlib/malloc/heap_free.c @@ -0,0 +1,127 @@ +/* + * libc/stdlib/malloc-zarg/heap_free.c -- return memory to a heap + * + * Copyright (C) 2002 NEC Corporation + * Copyright (C) 2002 Miles Bader + * + * This file is subject to the terms and conditions of the GNU Lesser + * General Public License. See the file COPYING.LIB in the main + * directory of this archive for more details. + * + * Written by Miles Bader + */ + +#include + +#include "heap.h" + + +/* Return the memory area MEM of size SIZE to HEAP. */ +void +__heap_free (struct heap *heap, void *mem, size_t size) +{ + struct heap_free_area *prev_fa, *fa, *new_fa; + void *end = (char *)mem + size; + + mutex_lock (heap->lock); + + HEAP_DEBUG (heap, "before __heap_free"); + + /* Find an adjacent free-list entry. */ + for (prev_fa = 0, fa = heap->free_areas; fa; prev_fa = fa, fa = fa->next) + { + size_t fa_size = fa->size; + void *fa_end = HEAP_FREE_AREA_END (fa); + void *fa_mem = HEAP_FREE_AREA_START (fa); + + if (fa_mem == end) + /* FA is just after MEM, grow down to encompass it. */ + { + fa_size += size; + + /* See if FA can now be merged with its predecessor. */ + if (prev_fa && fa_mem - size == HEAP_FREE_AREA_END (prev_fa)) + /* Yup; merge PREV_FA's info into FA. */ + { + struct heap_free_area *pp = prev_fa->prev; + fa_size += prev_fa->size; + if (pp) + pp->next = fa; + else + heap->free_areas = fa; + fa->prev = pp; + } + + fa->size = fa_size; + + goto done; + } + else if (fa_end == mem) + /* FA is just before MEM, expand to encompass it. */ + { + struct heap_free_area *next_fa = fa->next; + + fa_size += size; + + /* See if FA can now be merged with its successor. */ + if (next_fa && fa_end + size == HEAP_FREE_AREA_START (next_fa)) + { + /* Yup; merge FA's info into NEXT_FA. */ + fa_size += next_fa->size; + if (prev_fa) + prev_fa->next = next_fa; + else + heap->free_areas = next_fa; + next_fa->prev = prev_fa; + fa = next_fa; + } + else + /* FA can't be merged; move the descriptor for it to the tail-end + of the memory block. */ + { + new_fa = (struct heap_free_area *)((char *)fa + size); + /* Update surrounding free-areas to point to FA's new address. */ + if (prev_fa) + prev_fa->next = new_fa; + else + heap->free_areas = new_fa; + if (next_fa) + next_fa->prev = new_fa; + /* Fill in the moved descriptor. */ + new_fa->prev = prev_fa; + new_fa->next = next_fa; + fa = new_fa; + } + + fa->size = fa_size; + + goto done; + } + else if (fa_mem > mem) + /* We've reached the right spot in the free-list without finding an + adjacent free-area, so add a new free area to hold MEM. */ + break; + } + + /* Make a new free-list entry. */ + + /* NEW_FA initially holds only MEM. */ + new_fa = (struct heap_free_area *) + ((char *)mem + size - sizeof (struct heap_free_area)); + new_fa->size = size; + new_fa->next = fa; + new_fa->prev = prev_fa; + + /* Insert NEW_FA in the free-list between PREV_FA and FA. */ + if (prev_fa) + prev_fa->next = new_fa; + else + heap->free_areas = new_fa; + if (fa) + fa->prev = new_fa; + + done: + HEAP_DEBUG (heap, "after __heap_free"); + + mutex_unlock (heap->lock); +} -- cgit v1.2.3