| /* |
| * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers |
| * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. |
| * Copyright (c) 1998 by Silicon Graphics. All rights reserved. |
| * |
| * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED |
| * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. |
| * |
| * Permission is hereby granted to use or copy this program |
| * for any purpose, provided the above notices are retained on all copies. |
| * Permission to modify the code and to distribute modified code is granted, |
| * provided the above notices are retained, and a notice that the code was |
| * modified is included with the above copyright notice. |
| */ |
| /* Boehm, August 9, 1995 5:08 pm PDT */ |
| |
| #define DEBUG |
| #undef DEBUG |
| #include <stdio.h> |
| #include "gc_priv.h" |
| |
| |
| /* |
| * allocate/free routines for heap blocks |
| * Note that everything called from outside the garbage collector |
| * should be prepared to abort at any point as the result of a signal. |
| */ |
| |
| /* |
| * Free heap blocks are kept on a list sorted by address. |
| * The hb_hdr.hbh_sz field of a free heap block contains the length |
| * (in bytes) of the entire block. |
| * Neighbors are coalesced. |
| */ |
| |
| # define MAX_BLACK_LIST_ALLOC (2*HBLKSIZE) |
| /* largest block we will allocate starting on a black */ |
| /* listed block. Must be >= HBLKSIZE. */ |
| |
| struct hblk * GC_hblkfreelist = 0; |
| |
| struct hblk *GC_savhbp = (struct hblk *)0; /* heap block preceding next */ |
| /* block to be examined by */ |
| /* GC_allochblk. */ |
| |
| # if !defined(NO_DEBUGGING) |
| void GC_print_hblkfreelist() |
| { |
| struct hblk * h = GC_hblkfreelist; |
| word total_free = 0; |
| hdr * hhdr = HDR(h); |
| word sz; |
| |
| while (h != 0) { |
| sz = hhdr -> hb_sz; |
| GC_printf2("0x%lx size %lu ", (unsigned long)h, (unsigned long)sz); |
| total_free += sz; |
| if (GC_is_black_listed(h, HBLKSIZE) != 0) { |
| GC_printf0("start black listed\n"); |
| } else if (GC_is_black_listed(h, hhdr -> hb_sz) != 0) { |
| GC_printf0("partially black listed\n"); |
| } else { |
| GC_printf0("not black listed\n"); |
| } |
| h = hhdr -> hb_next; |
| hhdr = HDR(h); |
| } |
| GC_printf1("Total of %lu bytes on free list\n", (unsigned long)total_free); |
| } |
| |
| # endif /* NO_DEBUGGING */ |
| |
| /* Initialize hdr for a block containing the indicated size and */ |
| /* kind of objects. */ |
| /* Return FALSE on failure. */ |
| static GC_bool setup_header(hhdr, sz, kind, flags) |
| register hdr * hhdr; |
| word sz; /* object size in words */ |
| int kind; |
| unsigned char flags; |
| { |
| register word descr; |
| |
| /* Add description of valid object pointers */ |
| if (!GC_add_map_entry(sz)) return(FALSE); |
| hhdr -> hb_map = GC_obj_map[sz > MAXOBJSZ? 0 : sz]; |
| |
| /* Set size, kind and mark proc fields */ |
| hhdr -> hb_sz = sz; |
| hhdr -> hb_obj_kind = kind; |
| hhdr -> hb_flags = flags; |
| descr = GC_obj_kinds[kind].ok_descriptor; |
| if (GC_obj_kinds[kind].ok_relocate_descr) descr += WORDS_TO_BYTES(sz); |
| hhdr -> hb_descr = descr; |
| |
| /* Clear mark bits */ |
| GC_clear_hdr_marks(hhdr); |
| |
| hhdr -> hb_last_reclaimed = (unsigned short)GC_gc_no; |
| return(TRUE); |
| } |
| |
| #ifdef EXACT_FIRST |
| # define LAST_TRIP 2 |
| #else |
| # define LAST_TRIP 1 |
| #endif |
| |
| /* |
| * Allocate (and return pointer to) a heap block |
| * for objects of size sz words. |
| * |
| * NOTE: We set obj_map field in header correctly. |
| * Caller is resposnsible for building an object freelist in block. |
| * |
| * We clear the block if it is destined for large objects, and if |
| * kind requires that newly allocated objects be cleared. |
| */ |
| struct hblk * |
| GC_allochblk(sz, kind, flags) |
| word sz; |
| int kind; |
| unsigned char flags; /* IGNORE_OFF_PAGE or 0 */ |
| { |
| register struct hblk *thishbp; |
| register hdr * thishdr; /* Header corr. to thishbp */ |
| register struct hblk *hbp; |
| register hdr * hhdr; /* Header corr. to hbp */ |
| struct hblk *prevhbp; |
| register hdr * phdr; /* Header corr. to prevhbp */ |
| signed_word size_needed; /* number of bytes in requested objects */ |
| signed_word size_avail; /* bytes available in this block */ |
| int trip_count = 0; |
| |
| size_needed = HBLKSIZE * OBJ_SZ_TO_BLOCKS(sz); |
| |
| /* search for a big enough block in free list */ |
| hbp = GC_savhbp; |
| hhdr = HDR(hbp); |
| for(;;) { |
| |
| prevhbp = hbp; |
| phdr = hhdr; |
| hbp = (prevhbp == 0? GC_hblkfreelist : phdr->hb_next); |
| hhdr = HDR(hbp); |
| |
| if( prevhbp == GC_savhbp) { |
| if (trip_count == LAST_TRIP) return(0); |
| ++trip_count; |
| } |
| |
| if( hbp == 0 ) continue; |
| |
| size_avail = hhdr->hb_sz; |
| # ifdef EXACT_FIRST |
| if (trip_count <= 1 && size_avail != size_needed) continue; |
| # endif |
| if (size_avail < size_needed) continue; |
| # ifdef PRESERVE_LAST |
| if (size_avail != size_needed |
| && !GC_incremental |
| && GC_in_last_heap_sect(hbp) && GC_should_collect()) { |
| continue; |
| } |
| # endif |
| /* If the next heap block is obviously better, go on. */ |
| /* This prevents us from disassembling a single large block */ |
| /* to get tiny blocks. */ |
| { |
| signed_word next_size; |
| |
| thishbp = hhdr -> hb_next; |
| if (thishbp == 0) thishbp = GC_hblkfreelist; |
| thishdr = HDR(thishbp); |
| next_size = (signed_word)(thishdr -> hb_sz); |
| if (next_size < size_avail |
| && next_size >= size_needed |
| && !GC_is_black_listed(thishbp, (word)size_needed)) { |
| continue; |
| } |
| } |
| if ( !IS_UNCOLLECTABLE(kind) && |
| (kind != PTRFREE || size_needed > MAX_BLACK_LIST_ALLOC)) { |
| struct hblk * lasthbp = hbp; |
| ptr_t search_end = (ptr_t)hbp + size_avail - size_needed; |
| signed_word orig_avail = size_avail; |
| signed_word eff_size_needed = ((flags & IGNORE_OFF_PAGE)? |
| HBLKSIZE |
| : size_needed); |
| |
| |
| while ((ptr_t)lasthbp <= search_end |
| && (thishbp = GC_is_black_listed(lasthbp, |
| (word)eff_size_needed))) { |
| lasthbp = thishbp; |
| } |
| size_avail -= (ptr_t)lasthbp - (ptr_t)hbp; |
| thishbp = lasthbp; |
| if (size_avail >= size_needed) { |
| if (thishbp != hbp && GC_install_header(thishbp)) { |
| /* Split the block at thishbp */ |
| thishdr = HDR(thishbp); |
| /* GC_invalidate_map not needed, since we will */ |
| /* allocate this block. */ |
| thishdr -> hb_next = hhdr -> hb_next; |
| thishdr -> hb_sz = size_avail; |
| hhdr -> hb_sz = (ptr_t)thishbp - (ptr_t)hbp; |
| hhdr -> hb_next = thishbp; |
| /* Advance to thishbp */ |
| prevhbp = hbp; |
| phdr = hhdr; |
| hbp = thishbp; |
| hhdr = thishdr; |
| } |
| } else if (size_needed > (signed_word)BL_LIMIT |
| && orig_avail - size_needed |
| > (signed_word)BL_LIMIT) { |
| /* Punt, since anything else risks unreasonable heap growth. */ |
| WARN("Needed to allocate blacklisted block at 0x%lx\n", |
| (word)hbp); |
| thishbp = hbp; |
| size_avail = orig_avail; |
| } else if (size_avail == 0 |
| && size_needed == HBLKSIZE |
| && prevhbp != 0) { |
| # ifndef FIND_LEAK |
| static unsigned count = 0; |
| |
| /* The block is completely blacklisted. We need */ |
| /* to drop some such blocks, since otherwise we spend */ |
| /* all our time traversing them if pointerfree */ |
| /* blocks are unpopular. */ |
| /* A dropped block will be reconsidered at next GC. */ |
| if ((++count & 3) == 0) { |
| /* Allocate and drop the block in small chunks, to */ |
| /* maximize the chance that we will recover some */ |
| /* later. */ |
| struct hblk * limit = hbp + (hhdr->hb_sz/HBLKSIZE); |
| struct hblk * h; |
| |
| GC_words_wasted += hhdr->hb_sz; |
| phdr -> hb_next = hhdr -> hb_next; |
| for (h = hbp; h < limit; h++) { |
| if (h == hbp || GC_install_header(h)) { |
| hhdr = HDR(h); |
| (void) setup_header( |
| hhdr, |
| BYTES_TO_WORDS(HBLKSIZE - HDR_BYTES), |
| PTRFREE, 0); /* Cant fail */ |
| if (GC_debugging_started) { |
| BZERO(hbp + HDR_BYTES, HBLKSIZE - HDR_BYTES); |
| } |
| } |
| } |
| /* Restore hbp to point at free block */ |
| if (GC_savhbp == hbp) GC_savhbp = prevhbp; |
| hbp = prevhbp; |
| hhdr = phdr; |
| if (hbp == GC_savhbp) --trip_count; |
| } |
| # endif |
| } |
| } |
| if( size_avail >= size_needed ) { |
| /* found a big enough block */ |
| /* let thishbp --> the block */ |
| /* set prevhbp, hbp to bracket it */ |
| thishbp = hbp; |
| thishdr = hhdr; |
| if( size_avail == size_needed ) { |
| hbp = hhdr->hb_next; |
| hhdr = HDR(hbp); |
| } else { |
| hbp = (struct hblk *) |
| (((word)thishbp) + size_needed); |
| if (!GC_install_header(hbp)) { |
| hbp = thishbp; |
| continue; |
| } |
| hhdr = HDR(hbp); |
| GC_invalidate_map(hhdr); |
| hhdr->hb_next = thishdr->hb_next; |
| hhdr->hb_sz = size_avail - size_needed; |
| } |
| /* remove *thishbp from hblk freelist */ |
| if( prevhbp == 0 ) { |
| GC_hblkfreelist = hbp; |
| } else { |
| phdr->hb_next = hbp; |
| } |
| /* save current list search position */ |
| GC_savhbp = hbp; |
| break; |
| } |
| } |
| |
| /* Notify virtual dirty bit implementation that we are about to write. */ |
| GC_write_hint(thishbp); |
| |
| /* Add it to map of valid blocks */ |
| if (!GC_install_counts(thishbp, (word)size_needed)) return(0); |
| /* This leaks memory under very rare conditions. */ |
| |
| /* Set up header */ |
| if (!setup_header(thishdr, sz, kind, flags)) { |
| GC_remove_counts(thishbp, (word)size_needed); |
| return(0); /* ditto */ |
| } |
| |
| /* Clear block if necessary */ |
| if (GC_debugging_started |
| || sz > MAXOBJSZ && GC_obj_kinds[kind].ok_init) { |
| BZERO(thishbp + HDR_BYTES, size_needed - HDR_BYTES); |
| } |
| |
| /* We just successfully allocated a block. Restart count of */ |
| /* consecutive failures. */ |
| { |
| extern unsigned GC_fail_count; |
| |
| GC_fail_count = 0; |
| } |
| |
| return( thishbp ); |
| } |
| |
| struct hblk * GC_freehblk_ptr = 0; /* Search position hint for GC_freehblk */ |
| |
| /* |
| * Free a heap block. |
| * |
| * Coalesce the block with its neighbors if possible. |
| * |
| * All mark words are assumed to be cleared. |
| */ |
| void |
| GC_freehblk(p) |
| register struct hblk *p; |
| { |
| register hdr *phdr; /* Header corresponding to p */ |
| register struct hblk *hbp, *prevhbp; |
| register hdr *hhdr, *prevhdr; |
| register signed_word size; |
| |
| /* GC_savhbp may become invalid due to coalescing. Clear it. */ |
| GC_savhbp = (struct hblk *)0; |
| |
| phdr = HDR(p); |
| size = phdr->hb_sz; |
| size = HBLKSIZE * OBJ_SZ_TO_BLOCKS(size); |
| GC_remove_counts(p, (word)size); |
| phdr->hb_sz = size; |
| GC_invalidate_map(phdr); |
| prevhbp = 0; |
| |
| /* The following optimization was suggested by David Detlefs. */ |
| /* Note that the header cannot be NIL, since there cannot be an */ |
| /* intervening call to GC_freehblk without resetting */ |
| /* GC_freehblk_ptr. */ |
| if (GC_freehblk_ptr != 0 && |
| HDR(GC_freehblk_ptr)->hb_map == GC_invalid_map && |
| (ptr_t)GC_freehblk_ptr < (ptr_t)p) { |
| hbp = GC_freehblk_ptr; |
| } else { |
| hbp = GC_hblkfreelist; |
| }; |
| hhdr = HDR(hbp); |
| |
| while( (hbp != 0) && (hbp < p) ) { |
| prevhbp = hbp; |
| prevhdr = hhdr; |
| hbp = hhdr->hb_next; |
| hhdr = HDR(hbp); |
| } |
| GC_freehblk_ptr = prevhbp; |
| |
| /* Check for duplicate deallocation in the easy case */ |
| if (hbp != 0 && (ptr_t)p + size > (ptr_t)hbp |
| || prevhbp != 0 && (ptr_t)prevhbp + prevhdr->hb_sz > (ptr_t)p) { |
| GC_printf1("Duplicate large block deallocation of 0x%lx\n", |
| (unsigned long) p); |
| GC_printf2("Surrounding free blocks are 0x%lx and 0x%lx\n", |
| (unsigned long) prevhbp, (unsigned long) hbp); |
| } |
| |
| /* Coalesce with successor, if possible */ |
| if( (((word)p)+size) == ((word)hbp) ) { |
| phdr->hb_next = hhdr->hb_next; |
| phdr->hb_sz += hhdr->hb_sz; |
| GC_remove_header(hbp); |
| } else { |
| phdr->hb_next = hbp; |
| } |
| |
| |
| if( prevhbp == 0 ) { |
| GC_hblkfreelist = p; |
| } else if( (((word)prevhbp) + prevhdr->hb_sz) |
| == ((word)p) ) { |
| /* Coalesce with predecessor */ |
| prevhdr->hb_next = phdr->hb_next; |
| prevhdr->hb_sz += phdr->hb_sz; |
| GC_remove_header(p); |
| } else { |
| prevhdr->hb_next = p; |
| } |
| } |
| |
