This is finalize.c in view mode; [Download] [Up]
/* * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers * Copyright (c) 1991, 1992 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 copy this garbage collector for any purpose, * provided the above notices are retained on all copies. */ # define I_HIDE_POINTERS # include "gc.h" # include "gc_private.h" # ifdef __STDC__ typedef void * void_star; # else typedef char * void_star; # endif # define LOG_TSIZE 7 # define TSIZE (1 << LOG_TSIZE) # define HASH(addr) \ ((((word)(addr) >> 3) ^ ((word)(addr) >> (3+LOG_TSIZE))) \ & (TSIZE - 1)) static struct disappearing_link { word dl_hidden_obj; /* Pointer to object base */ word dl_hidden_link; /* Field to be cleared. */ struct disappearing_link * dl_next; } * dl_head[TSIZE] = {0}; static struct finalizable_object { word fo_hidden_base; /* Pointer to object base */ GC_finalization_proc fo_fn; /* Finalizer. */ ptr_t fo_client_data; word fo_object_size; /* In bytes. */ struct finalizable_object * fo_next; } * fo_head[TSIZE] = {0}; # define ALLOC(x, t) t *x = (t *)GC_malloc(sizeof (t)) int GC_register_disappearing_link(link) void_star * link; { ptr_t base; base = (ptr_t)GC_base((void_star)link); if (base == 0) ABORT("Bad arg to GC_register_disappearing_link"); return(GC_general_register_disappearing_link(link, base)); } int GC_general_register_disappearing_link(link, obj) void_star * link; void_star obj; { struct disappearing_link *curr_dl; int index; /* Allocate before acquiring lock */ ALLOC(new_dl, struct disappearing_link); DCL_LOCK_STATE; index = HASH(link); if ((word)link & (ALIGNMENT-1)) ABORT("Bad arg to GC_general_register_disappearing_link"); DISABLE_SIGNALS(); LOCK(); curr_dl = dl_head[index]; for (curr_dl = dl_head[index]; curr_dl != 0; curr_dl = curr_dl -> dl_next) { if (curr_dl -> dl_hidden_link == HIDE_POINTER(link)) { curr_dl -> dl_hidden_obj = HIDE_POINTER(obj); UNLOCK(); ENABLE_SIGNALS(); GC_free((extern_ptr_t)new_dl); return(1); } } { new_dl -> dl_hidden_obj = HIDE_POINTER(obj); new_dl -> dl_hidden_link = HIDE_POINTER(link); new_dl -> dl_next = dl_head[index]; dl_head[index] = new_dl; UNLOCK(); ENABLE_SIGNALS(); return(0); } } int GC_unregister_disappearing_link(link) void_star * link; { struct disappearing_link *curr_dl, *prev_dl; int index; DCL_LOCK_STATE; DISABLE_SIGNALS(); LOCK(); index = HASH(link); if (((unsigned long)link & (ALIGNMENT-1))) return(0); prev_dl = 0; curr_dl = dl_head[index]; while (curr_dl != 0) { if (curr_dl -> dl_hidden_link == HIDE_POINTER(link)) { if (prev_dl == 0) { dl_head[index] = curr_dl -> dl_next; } else { prev_dl -> dl_next = curr_dl -> dl_next; } UNLOCK(); ENABLE_SIGNALS(); GC_free((extern_ptr_t)curr_dl); return(1); } curr_dl = curr_dl -> dl_next; prev_dl = curr_dl; } UNLOCK(); ENABLE_SIGNALS(); return(0); } void GC_register_finalizer(obj, fn, cd, ofn, ocd) void_star obj; GC_finalization_proc fn; void_star cd; GC_finalization_proc * ofn; void_star * ocd; { ptr_t base; struct finalizable_object * curr_fo, * prev_fo; int index; /* Allocate before acquiring lock */ ALLOC(new_fo, struct finalizable_object); DCL_LOCK_STATE; DISABLE_SIGNALS(); LOCK(); base = (ptr_t)GC_base((void_star)obj); index = HASH(base); if (base != obj) ABORT("Bad arg to GC_register_finalizer"); prev_fo = 0; curr_fo = fo_head[index]; while (curr_fo != 0) { if (curr_fo -> fo_hidden_base == HIDE_POINTER(base)) { if (ofn) *ofn = curr_fo -> fo_fn; if (ocd) *ocd = (void_star) curr_fo -> fo_client_data; if (fn == 0) { /* Delete the structure for base. */ if (prev_fo == 0) { fo_head[index] = curr_fo -> fo_next; } else { prev_fo -> fo_next = curr_fo -> fo_next; } UNLOCK(); ENABLE_SIGNALS(); GC_free((extern_ptr_t)curr_fo); } else { curr_fo -> fo_fn = fn; curr_fo -> fo_client_data = (ptr_t)cd; UNLOCK(); ENABLE_SIGNALS(); } GC_free((extern_ptr_t)new_fo); return; } curr_fo = curr_fo -> fo_next; prev_fo = curr_fo; } { if (ofn) *ofn = 0; if (ocd) *ocd = 0; if (fn == 0) { UNLOCK(); ENABLE_SIGNALS(); GC_free((extern_ptr_t)new_fo); return; } new_fo -> fo_hidden_base = (word)HIDE_POINTER(base); new_fo -> fo_fn = fn; new_fo -> fo_client_data = (ptr_t)cd; new_fo -> fo_object_size = GC_size(base); new_fo -> fo_next = fo_head[index]; fo_head[index] = new_fo; } UNLOCK(); ENABLE_SIGNALS(); } /* Called with world stopped. Cause disappearing links to disappear, */ /* and invoke finalizers. */ void GC_finalize() { struct disappearing_link * curr_dl, * prev_dl, * next_dl; struct finalizable_object * curr_fo, * prev_fo, * next_fo; ptr_t real_ptr; register int i; /* Make disappearing links disappear */ for (i = 0; i < TSIZE; i++) { curr_dl = dl_head[i]; prev_dl = 0; while (curr_dl != 0) { real_ptr = (ptr_t)REVEAL_POINTER(curr_dl -> dl_hidden_obj); if (!GC_is_marked(real_ptr)) { *(word *)(REVEAL_POINTER(curr_dl -> dl_hidden_link)) = 0; next_dl = curr_dl -> dl_next; if (prev_dl == 0) { dl_head[i] = next_dl; } else { prev_dl -> dl_next = next_dl; } GC_clear_mark_bit((ptr_t)curr_dl); curr_dl = next_dl; } else { prev_dl = curr_dl; curr_dl = curr_dl -> dl_next; } } } /* Mark all objects reachable via chains of 1 or more pointers */ /* from finalizable objects. */ for (i = 0; i < TSIZE; i++) { for (curr_fo = fo_head[i]; curr_fo != 0; curr_fo = curr_fo -> fo_next) { real_ptr = (ptr_t)REVEAL_POINTER(curr_fo -> fo_hidden_base); if (!GC_is_marked(real_ptr)) { GC_push_all(real_ptr, real_ptr + curr_fo -> fo_object_size); while (!GC_mark_stack_empty()) GC_mark_from_mark_stack(); } /* if (GC_is_marked(real_ptr)) { --> Report finalization cycle here, if desired } */ } } /* Invoke finalization code for all objects that are still */ /* unreachable. */ for (i = 0; i < TSIZE; i++) { curr_fo = fo_head[i]; prev_fo = 0; while (curr_fo != 0) { real_ptr = (ptr_t)REVEAL_POINTER(curr_fo -> fo_hidden_base); if (!GC_is_marked(real_ptr)) { (*(curr_fo -> fo_fn))(real_ptr, curr_fo -> fo_client_data); GC_set_mark_bit(real_ptr); next_fo = curr_fo -> fo_next; if (prev_fo == 0) { fo_head[i] = next_fo; } else { prev_fo -> fo_next = next_fo; } if (!GC_is_marked((ptr_t)curr_fo)) { ABORT("GC_finalize: found accessible unmarked object\n"); } GC_clear_mark_bit((ptr_t)curr_fo); curr_fo = next_fo; } else { prev_fo = curr_fo; curr_fo = curr_fo -> fo_next; } } } } # ifdef __STDC__ void_star GC_call_with_alloc_lock(GC_fn_type fn, void_star client_data) # else void_star GC_call_with_alloc_lock(fn, client_data) GC_fn_type fn; void_star client_data; # endif { DCL_LOCK_STATE; DISABLE_SIGNALS(); LOCK(); (*fn)(client_data); UNLOCK(); ENABLE_SIGNALS(); }
These are the contents of the former NiCE NeXT User Group NeXTSTEP/OpenStep software archive, currently hosted by Netfuture.ch.