URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [boehm-gc/] [stubborn.c] - Rev 775
Go to most recent revision | Compare with Previous | Blame | View Log
/* * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers * Copyright (c) 1991-1994 by Xerox Corporation. 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, July 31, 1995 5:02 pm PDT */ #include "private/gc_priv.h" # ifdef STUBBORN_ALLOC /* Stubborn object (hard to change, nearly immutable) allocation. */ extern ptr_t GC_clear_stack(); /* in misc.c, behaves like identity */ #define GENERAL_MALLOC(lb,k) \ (GC_PTR)GC_clear_stack(GC_generic_malloc((word)lb, k)) /* Data structure representing immutable objects that */ /* are still being initialized. */ /* This is a bit baroque in order to avoid acquiring */ /* the lock twice for a typical allocation. */ GC_PTR * GC_changing_list_start; void GC_push_stubborn_structures GC_PROTO((void)) { GC_push_all((ptr_t)(&GC_changing_list_start), (ptr_t)(&GC_changing_list_start) + sizeof(GC_PTR *)); } # ifdef THREADS VOLATILE GC_PTR * VOLATILE GC_changing_list_current; # else GC_PTR * GC_changing_list_current; # endif /* Points at last added element. Also (ab)used for */ /* synchronization. Updates and reads are assumed atomic. */ GC_PTR * GC_changing_list_limit; /* Points at the last word of the buffer, which is always 0 */ /* All entries in (GC_changing_list_current, */ /* GC_changing_list_limit] are 0 */ void GC_stubborn_init() { # define INIT_SIZE 10 GC_changing_list_start = (GC_PTR *) GC_INTERNAL_MALLOC( (word)(INIT_SIZE * sizeof(GC_PTR)), PTRFREE); BZERO(GC_changing_list_start, INIT_SIZE * sizeof(GC_PTR)); if (GC_changing_list_start == 0) { GC_err_printf0("Insufficient space to start up\n"); ABORT("GC_stubborn_init: put of space"); } GC_changing_list_current = GC_changing_list_start; GC_changing_list_limit = GC_changing_list_start + INIT_SIZE - 1; * GC_changing_list_limit = 0; } /* Compact and possibly grow GC_uninit_list. The old copy is */ /* left alone. Lock must be held. */ /* When called GC_changing_list_current == GC_changing_list_limit */ /* which is one past the current element. */ /* When we finish GC_changing_list_current again points one past last */ /* element. */ /* Invariant while this is running: GC_changing_list_current */ /* points at a word containing 0. */ /* Returns FALSE on failure. */ GC_bool GC_compact_changing_list() { register GC_PTR *p, *q; register word count = 0; word old_size = (char **)GC_changing_list_limit - (char **)GC_changing_list_start+1; /* The casts are needed as a workaround for an Amiga bug */ register word new_size = old_size; GC_PTR * new_list; for (p = GC_changing_list_start; p < GC_changing_list_limit; p++) { if (*p != 0) count++; } if (2 * count > old_size) new_size = 2 * count; new_list = (GC_PTR *) GC_INTERNAL_MALLOC( new_size * sizeof(GC_PTR), PTRFREE); /* PTRFREE is a lie. But we don't want the collector to */ /* consider these. We do want the list itself to be */ /* collectable. */ if (new_list == 0) return(FALSE); BZERO(new_list, new_size * sizeof(GC_PTR)); q = new_list; for (p = GC_changing_list_start; p < GC_changing_list_limit; p++) { if (*p != 0) *q++ = *p; } GC_changing_list_start = new_list; GC_changing_list_limit = new_list + new_size - 1; GC_changing_list_current = q; return(TRUE); } /* Add p to changing list. Clear p on failure. */ # define ADD_CHANGING(p) \ { \ register struct hblk * h = HBLKPTR(p); \ register word index = PHT_HASH(h); \ \ set_pht_entry_from_index(GC_changed_pages, index); \ } \ if (*GC_changing_list_current != 0 \ && ++GC_changing_list_current == GC_changing_list_limit) { \ if (!GC_compact_changing_list()) (p) = 0; \ } \ *GC_changing_list_current = p; void GC_change_stubborn(p) GC_PTR p; { DCL_LOCK_STATE; DISABLE_SIGNALS(); LOCK(); ADD_CHANGING(p); UNLOCK(); ENABLE_SIGNALS(); } void GC_end_stubborn_change(p) GC_PTR p; { # ifdef THREADS register VOLATILE GC_PTR * my_current = GC_changing_list_current; # else register GC_PTR * my_current = GC_changing_list_current; # endif register GC_bool tried_quick; DCL_LOCK_STATE; if (*my_current == p) { /* Hopefully the normal case. */ /* Compaction could not have been running when we started. */ *my_current = 0; # ifdef THREADS if (my_current == GC_changing_list_current) { /* Compaction can't have run in the interim. */ /* We got away with the quick and dirty approach. */ return; } tried_quick = TRUE; # else return; # endif } else { tried_quick = FALSE; } DISABLE_SIGNALS(); LOCK(); my_current = GC_changing_list_current; for (; my_current >= GC_changing_list_start; my_current--) { if (*my_current == p) { *my_current = 0; UNLOCK(); ENABLE_SIGNALS(); return; } } if (!tried_quick) { GC_err_printf1("Bad arg to GC_end_stubborn_change: 0x%lx\n", (unsigned long)p); ABORT("Bad arg to GC_end_stubborn_change"); } UNLOCK(); ENABLE_SIGNALS(); } /* Allocate lb bytes of composite (pointerful) data */ /* No pointer fields may be changed after a call to */ /* GC_end_stubborn_change(p) where p is the value */ /* returned by GC_malloc_stubborn. */ # ifdef __STDC__ GC_PTR GC_malloc_stubborn(size_t lb) # else GC_PTR GC_malloc_stubborn(lb) size_t lb; # endif { register ptr_t op; register ptr_t *opp; register word lw; ptr_t result; DCL_LOCK_STATE; if( SMALL_OBJ(lb) ) { # ifdef MERGE_SIZES lw = GC_size_map[lb]; # else lw = ALIGNED_WORDS(lb); # endif opp = &(GC_sobjfreelist[lw]); FASTLOCK(); if( !FASTLOCK_SUCCEEDED() || (op = *opp) == 0 ) { FASTUNLOCK(); result = GC_generic_malloc((word)lb, STUBBORN); goto record; } *opp = obj_link(op); obj_link(op) = 0; GC_words_allocd += lw; result = (GC_PTR) op; ADD_CHANGING(result); FASTUNLOCK(); return((GC_PTR)result); } else { result = (GC_PTR) GC_generic_malloc((word)lb, STUBBORN); } record: DISABLE_SIGNALS(); LOCK(); ADD_CHANGING(result); UNLOCK(); ENABLE_SIGNALS(); return((GC_PTR)GC_clear_stack(result)); } /* Functions analogous to GC_read_dirty and GC_page_was_dirty. */ /* Report pages on which stubborn objects were changed. */ void GC_read_changed() { register GC_PTR * p = GC_changing_list_start; register GC_PTR q; register struct hblk * h; register word index; if (p == 0) /* initializing */ return; BCOPY(GC_changed_pages, GC_prev_changed_pages, (sizeof GC_changed_pages)); BZERO(GC_changed_pages, (sizeof GC_changed_pages)); for (; p <= GC_changing_list_current; p++) { if ((q = *p) != 0) { h = HBLKPTR(q); index = PHT_HASH(h); set_pht_entry_from_index(GC_changed_pages, index); } } } GC_bool GC_page_was_changed(h) struct hblk * h; { register word index = PHT_HASH(h); return(get_pht_entry_from_index(GC_prev_changed_pages, index)); } /* Remove unreachable entries from changed list. Should only be */ /* called with mark bits consistent and lock held. */ void GC_clean_changing_list() { register GC_PTR * p = GC_changing_list_start; register GC_PTR q; register ptr_t r; register unsigned long count = 0; register unsigned long dropped_count = 0; if (p == 0) /* initializing */ return; for (; p <= GC_changing_list_current; p++) { if ((q = *p) != 0) { count++; r = (ptr_t)GC_base(q); if (r == 0 || !GC_is_marked(r)) { *p = 0; dropped_count++; } } } # ifdef PRINTSTATS if (count > 0) { GC_printf2("%lu entries in changing list: reclaimed %lu\n", (unsigned long)count, (unsigned long)dropped_count); } # endif } #else /* !STUBBORN_ALLOC */ # ifdef __STDC__ GC_PTR GC_malloc_stubborn(size_t lb) # else GC_PTR GC_malloc_stubborn(lb) size_t lb; # endif { return(GC_malloc(lb)); } /*ARGSUSED*/ void GC_end_stubborn_change(p) GC_PTR p; { } /*ARGSUSED*/ void GC_change_stubborn(p) GC_PTR p; { } void GC_push_stubborn_structures GC_PROTO((void)) { } #endif
Go to most recent revision | Compare with Previous | Blame | View Log