X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=src%2Fmm%2Fboehm-gc%2Fblacklst.c;h=25ebea8e177a403031e27e6b524198b92b60bc0b;hb=c9ee016a64e925938f84fcb85521f82febcc4f63;hp=24075d30e931d23290c734feefb0c9cb2c40c670;hpb=29c5375943f6b0d6c2e2f77c07c13ae04dae5565;p=cacao.git diff --git a/src/mm/boehm-gc/blacklst.c b/src/mm/boehm-gc/blacklst.c index 24075d30e..25ebea8e1 100644 --- a/src/mm/boehm-gc/blacklst.c +++ b/src/mm/boehm-gc/blacklst.c @@ -1,4 +1,4 @@ -/* +/* * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. * @@ -11,11 +11,8 @@ * 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 6:09 pm PDT */ - -#include "config.h" -# include "private/gc_priv.h" +#include "private/gc_priv.h" /* * We maintain several hash tables of hblks that have had false hits. @@ -26,10 +23,10 @@ * from elsewhere, since the former can pin a large object that spans the * block, eventhough it does not start on the dangerous block. */ - + /* * Externally callable routines are: - + * GC_add_to_black_list_normal * GC_add_to_black_list_stack * GC_promote_black_lists @@ -38,63 +35,63 @@ * All require that the allocator lock is held. */ -/* Pointers to individual tables. We replace one table by another by */ -/* switching these pointers. */ -word * GC_old_normal_bl; - /* Nonstack false references seen at last full */ - /* collection. */ -word * GC_incomplete_normal_bl; - /* Nonstack false references seen since last */ - /* full collection. */ -word * GC_old_stack_bl; -word * GC_incomplete_stack_bl; +/* Pointers to individual tables. We replace one table by another by */ +/* switching these pointers. */ +STATIC word * GC_old_normal_bl = NULL; + /* Nonstack false references seen at last full */ + /* collection. */ +STATIC word * GC_incomplete_normal_bl = NULL; + /* Nonstack false references seen since last */ + /* full collection. */ +STATIC word * GC_old_stack_bl = NULL; +STATIC word * GC_incomplete_stack_bl = NULL; -word GC_total_stack_black_listed; +STATIC word GC_total_stack_black_listed = 0; + /* Number of bytes on stack blacklist. */ -word GC_black_list_spacing = MINHINCR*HBLKSIZE; /* Initial rough guess */ +GC_INNER word GC_black_list_spacing = MINHINCR * HBLKSIZE; + /* Initial rough guess. */ -void GC_clear_bl(); +STATIC void GC_clear_bl(word *); -# if defined(__STDC__) || defined(__cplusplus) - void GC_default_print_heap_obj_proc(ptr_t p) -# else - void GC_default_print_heap_obj_proc(p) - ptr_t p; -# endif +GC_INNER void GC_default_print_heap_obj_proc(ptr_t p) { ptr_t base = GC_base(p); - - GC_err_printf2("start: 0x%lx, appr. length: %ld", base, GC_size(base)); + GC_err_printf("start: %p, appr. length: %ld", base, + (unsigned long)GC_size(base)); } -void (*GC_print_heap_obj) GC_PROTO((ptr_t p)) = - GC_default_print_heap_obj_proc; +GC_INNER void (*GC_print_heap_obj)(ptr_t p) = GC_default_print_heap_obj_proc; -void GC_print_source_ptr(p) -ptr_t p; +#ifdef PRINT_BLACK_LIST +STATIC void GC_print_source_ptr(ptr_t p) { ptr_t base = GC_base(p); if (0 == base) { - if (0 == p) { - GC_err_printf0("in register"); - } else { - GC_err_printf0("in root set"); - } + if (0 == p) { + GC_err_printf("in register"); + } else { + GC_err_printf("in root set"); + } } else { - GC_err_printf0("in object at "); - (*GC_print_heap_obj)(base); + GC_err_printf("in object at "); + /* FIXME: We can't call the debug version of GC_print_heap_obj */ + /* (with PRINT_CALL_CHAIN) here because the lock is held and */ + /* the world is stopped. */ + GC_default_print_heap_obj_proc(base); } } +#endif -void GC_bl_init() +GC_INNER void GC_bl_init(void) { if (!GC_all_interior_pointers) { GC_old_normal_bl = (word *) - GC_scratch_alloc((word)(sizeof (page_hash_table))); + GC_scratch_alloc((word)(sizeof (page_hash_table))); GC_incomplete_normal_bl = (word *)GC_scratch_alloc - ((word)(sizeof(page_hash_table))); + ((word)(sizeof(page_hash_table))); if (GC_old_normal_bl == 0 || GC_incomplete_normal_bl == 0) { - GC_err_printf0("Insufficient memory for black list\n"); + GC_err_printf("Insufficient memory for black list\n"); EXIT(); } GC_clear_bl(GC_old_normal_bl); @@ -102,36 +99,34 @@ void GC_bl_init() } GC_old_stack_bl = (word *)GC_scratch_alloc((word)(sizeof(page_hash_table))); GC_incomplete_stack_bl = (word *)GC_scratch_alloc - ((word)(sizeof(page_hash_table))); + ((word)(sizeof(page_hash_table))); if (GC_old_stack_bl == 0 || GC_incomplete_stack_bl == 0) { - GC_err_printf0("Insufficient memory for black list\n"); + GC_err_printf("Insufficient memory for black list\n"); EXIT(); } GC_clear_bl(GC_old_stack_bl); GC_clear_bl(GC_incomplete_stack_bl); } - -void GC_clear_bl(doomed) -word *doomed; + +STATIC void GC_clear_bl(word *doomed) { BZERO(doomed, sizeof(page_hash_table)); } -void GC_copy_bl(old, new) -word *new, *old; +STATIC void GC_copy_bl(word *old, word *new) { BCOPY(old, new, sizeof(page_hash_table)); } -static word total_stack_black_listed(); +static word total_stack_black_listed(void); -/* Signal the completion of a collection. Turn the incomplete black */ -/* lists into new black lists, etc. */ -void GC_promote_black_lists() +/* Signal the completion of a collection. Turn the incomplete black */ +/* lists into new black lists, etc. */ +GC_INNER void GC_promote_black_lists(void) { word * very_old_normal_bl = GC_old_normal_bl; word * very_old_stack_bl = GC_old_stack_bl; - + GC_old_normal_bl = GC_incomplete_normal_bl; GC_old_stack_bl = GC_incomplete_stack_bl; if (!GC_all_interior_pointers) { @@ -141,27 +136,26 @@ void GC_promote_black_lists() GC_incomplete_normal_bl = very_old_normal_bl; GC_incomplete_stack_bl = very_old_stack_bl; GC_total_stack_black_listed = total_stack_black_listed(); -# ifdef PRINTSTATS - GC_printf1("%ld bytes in heap blacklisted for interior pointers\n", - (unsigned long)GC_total_stack_black_listed); -# endif + if (GC_print_stats == VERBOSE) + GC_log_printf("%ld bytes in heap blacklisted for interior pointers\n", + (unsigned long)GC_total_stack_black_listed); if (GC_total_stack_black_listed != 0) { GC_black_list_spacing = - HBLKSIZE*(GC_heapsize/GC_total_stack_black_listed); + HBLKSIZE*(GC_heapsize/GC_total_stack_black_listed); } if (GC_black_list_spacing < 3 * HBLKSIZE) { - GC_black_list_spacing = 3 * HBLKSIZE; + GC_black_list_spacing = 3 * HBLKSIZE; } if (GC_black_list_spacing > MAXHINCR * HBLKSIZE) { - GC_black_list_spacing = MAXHINCR * HBLKSIZE; - /* Makes it easier to allocate really huge blocks, which otherwise */ - /* may have problems with nonuniform blacklist distributions. */ - /* This way we should always succeed immediately after growing the */ - /* heap. */ + GC_black_list_spacing = MAXHINCR * HBLKSIZE; + /* Makes it easier to allocate really huge blocks, which otherwise */ + /* may have problems with nonuniform blacklist distributions. */ + /* This way we should always succeed immediately after growing the */ + /* heap. */ } } -void GC_unpromote_black_lists() +GC_INNER void GC_unpromote_black_lists(void) { if (!GC_all_interior_pointers) { GC_copy_bl(GC_old_normal_bl, GC_incomplete_normal_bl); @@ -169,59 +163,55 @@ void GC_unpromote_black_lists() GC_copy_bl(GC_old_stack_bl, GC_incomplete_stack_bl); } -/* P is not a valid pointer reference, but it falls inside */ -/* the plausible heap bounds. */ -/* Add it to the normal incomplete black list if appropriate. */ +/* P is not a valid pointer reference, but it falls inside */ +/* the plausible heap bounds. */ +/* Add it to the normal incomplete black list if appropriate. */ #ifdef PRINT_BLACK_LIST - void GC_add_to_black_list_normal(p, source) - ptr_t source; + GC_INNER void GC_add_to_black_list_normal(word p, ptr_t source) #else - void GC_add_to_black_list_normal(p) + GC_INNER void GC_add_to_black_list_normal(word p) #endif -word p; { if (!(GC_modws_valid_offsets[p & (sizeof(word)-1)])) return; { - register int index = PHT_HASH(p); - + word index = PHT_HASH((word)p); + if (HDR(p) == 0 || get_pht_entry_from_index(GC_old_normal_bl, index)) { -# ifdef PRINT_BLACK_LIST - if (!get_pht_entry_from_index(GC_incomplete_normal_bl, index)) { - GC_err_printf2( - "Black listing (normal) 0x%lx referenced from 0x%lx ", - (unsigned long) p, (unsigned long) source); - GC_print_source_ptr(source); - GC_err_puts("\n"); - } +# ifdef PRINT_BLACK_LIST + if (!get_pht_entry_from_index(GC_incomplete_normal_bl, index)) { + GC_err_printf( + "Black listing (normal) %p referenced from %p ", + (ptr_t) p, source); + GC_print_source_ptr(source); + GC_err_puts("\n"); + } # endif set_pht_entry_from_index(GC_incomplete_normal_bl, index); } /* else this is probably just an interior pointer to an allocated */ - /* object, and isn't worth black listing. */ + /* object, and isn't worth black listing. */ } } /* And the same for false pointers from the stack. */ #ifdef PRINT_BLACK_LIST - void GC_add_to_black_list_stack(p, source) - ptr_t source; + GC_INNER void GC_add_to_black_list_stack(word p, ptr_t source) #else - void GC_add_to_black_list_stack(p) + GC_INNER void GC_add_to_black_list_stack(word p) #endif -word p; { - register int index = PHT_HASH(p); - + word index = PHT_HASH((word)p); + if (HDR(p) == 0 || get_pht_entry_from_index(GC_old_stack_bl, index)) { -# ifdef PRINT_BLACK_LIST - if (!get_pht_entry_from_index(GC_incomplete_stack_bl, index)) { - GC_err_printf2( - "Black listing (stack) 0x%lx referenced from 0x%lx ", - (unsigned long)p, (unsigned long)source); - GC_print_source_ptr(source); - GC_err_puts("\n"); - } +# ifdef PRINT_BLACK_LIST + if (!get_pht_entry_from_index(GC_incomplete_stack_bl, index)) { + GC_err_printf( + "Black listing (stack) %p referenced from %p ", + (ptr_t)p, source); + GC_print_source_ptr(source); + GC_err_puts("\n"); + } # endif - set_pht_entry_from_index(GC_incomplete_stack_bl, index); + set_pht_entry_from_index(GC_incomplete_stack_bl, index); } } @@ -233,12 +223,10 @@ word p; * If (h,len) is not black listed, return 0. * Knows about the structure of the black list hash tables. */ -struct hblk * GC_is_black_listed(h, len) -struct hblk * h; -word len; +GC_INNER struct hblk * GC_is_black_listed(struct hblk *h, word len) { - register int index = PHT_HASH((word)h); - register word i; + word index = PHT_HASH((word)h); + word i; word nblocks = divHBLKSZ(len); if (!GC_all_interior_pointers) { @@ -247,8 +235,8 @@ word len; return(h+1); } } - - for (i = 0; ; ) { + + for (i = 0;;) { if (GC_old_stack_bl[divWORDSZ(index)] == 0 && GC_incomplete_stack_bl[divWORDSZ(index)] == 0) { /* An easy case */ @@ -266,38 +254,35 @@ word len; return(0); } - -/* Return the number of blacklisted blocks in a given range. */ -/* Used only for statistical purposes. */ -/* Looks only at the GC_incomplete_stack_bl. */ -word GC_number_stack_black_listed(start, endp1) -struct hblk *start, *endp1; +/* Return the number of blacklisted blocks in a given range. */ +/* Used only for statistical purposes. */ +/* Looks only at the GC_incomplete_stack_bl. */ +STATIC word GC_number_stack_black_listed(struct hblk *start, + struct hblk *endp1) { register struct hblk * h; word result = 0; - + for (h = start; h < endp1; h++) { - register int index = PHT_HASH((word)h); - + word index = PHT_HASH((word)h); + if (get_pht_entry_from_index(GC_old_stack_bl, index)) result++; } return(result); } - /* Return the total number of (stack) black-listed bytes. */ -static word total_stack_black_listed() +static word total_stack_black_listed(void) { register unsigned i; word total = 0; - + for (i = 0; i < GC_n_heap_sects; i++) { - struct hblk * start = (struct hblk *) GC_heap_sects[i].hs_start; - word len = (word) GC_heap_sects[i].hs_bytes; - struct hblk * endp1 = start + len/HBLKSIZE; - - total += GC_number_stack_black_listed(start, endp1); + struct hblk * start = (struct hblk *) GC_heap_sects[i].hs_start; + size_t len = (word) GC_heap_sects[i].hs_bytes; + struct hblk * endp1 = start + len/HBLKSIZE; + + total += GC_number_stack_black_listed(start, endp1); } return(total * HBLKSIZE); } -