Annotation of OpenXM_contrib2/asir2000/gc/finalize.c, Revision 1.1.1.1
1.1 noro 1: /*
2: * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
3: * Copyright (c) 1991-1996 by Xerox Corporation. All rights reserved.
4:
5: * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
6: * OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
7: *
8: * Permission is hereby granted to use or copy this program
9: * for any purpose, provided the above notices are retained on all copies.
10: * Permission to modify the code and to distribute modified code is granted,
11: * provided the above notices are retained, and a notice that the code was
12: * modified is included with the above copyright notice.
13: */
14: /* Boehm, February 1, 1996 1:19 pm PST */
15: # define I_HIDE_POINTERS
16: # include "gc_priv.h"
17: # include "gc_mark.h"
18:
19: /* Type of mark procedure used for marking from finalizable object. */
20: /* This procedure normally does not mark the object, only its */
21: /* descendents. */
22: typedef void finalization_mark_proc(/* ptr_t finalizable_obj_ptr */);
23:
24: # define HASH3(addr,size,log_size) \
25: ((((word)(addr) >> 3) ^ ((word)(addr) >> (3+(log_size)))) \
26: & ((size) - 1))
27: #define HASH2(addr,log_size) HASH3(addr, 1 << log_size, log_size)
28:
29: struct hash_chain_entry {
30: word hidden_key;
31: struct hash_chain_entry * next;
32: };
33:
34: unsigned GC_finalization_failures = 0;
35: /* Number of finalization requests that failed for lack of memory. */
36:
37: static struct disappearing_link {
38: struct hash_chain_entry prolog;
39: # define dl_hidden_link prolog.hidden_key
40: /* Field to be cleared. */
41: # define dl_next(x) (struct disappearing_link *)((x) -> prolog.next)
42: # define dl_set_next(x,y) (x) -> prolog.next = (struct hash_chain_entry *)(y)
43:
44: word dl_hidden_obj; /* Pointer to object base */
45: } **dl_head = 0;
46:
47: static signed_word log_dl_table_size = -1;
48: /* Binary log of */
49: /* current size of array pointed to by dl_head. */
50: /* -1 ==> size is 0. */
51:
52: word GC_dl_entries = 0; /* Number of entries currently in disappearing */
53: /* link table. */
54:
55: static struct finalizable_object {
56: struct hash_chain_entry prolog;
57: # define fo_hidden_base prolog.hidden_key
58: /* Pointer to object base. */
59: /* No longer hidden once object */
60: /* is on finalize_now queue. */
61: # define fo_next(x) (struct finalizable_object *)((x) -> prolog.next)
62: # define fo_set_next(x,y) (x) -> prolog.next = (struct hash_chain_entry *)(y)
63: GC_finalization_proc fo_fn; /* Finalizer. */
64: ptr_t fo_client_data;
65: word fo_object_size; /* In bytes. */
66: finalization_mark_proc * fo_mark_proc; /* Mark-through procedure */
67: } **fo_head = 0;
68:
69: struct finalizable_object * GC_finalize_now = 0;
70: /* LIst of objects that should be finalized now. */
71:
72: static signed_word log_fo_table_size = -1;
73:
74: word GC_fo_entries = 0;
75:
76: # ifdef SRC_M3
77: void GC_push_finalizer_structures()
78: {
79: GC_push_all((ptr_t)(&dl_head), (ptr_t)(&dl_head) + sizeof(word));
80: GC_push_all((ptr_t)(&fo_head), (ptr_t)(&fo_head) + sizeof(word));
81: }
82: # endif
83:
84: /* Double the size of a hash table. *size_ptr is the log of its current */
85: /* size. May be a noop. */
86: /* *table is a pointer to an array of hash headers. If we succeed, we */
87: /* update both *table and *log_size_ptr. */
88: /* Lock is held. Signals are disabled. */
89: void GC_grow_table(table, log_size_ptr)
90: struct hash_chain_entry ***table;
91: signed_word * log_size_ptr;
92: {
93: register word i;
94: register struct hash_chain_entry *p;
95: int log_old_size = *log_size_ptr;
96: register int log_new_size = log_old_size + 1;
97: word old_size = ((log_old_size == -1)? 0: (1 << log_old_size));
98: register word new_size = 1 << log_new_size;
99: struct hash_chain_entry **new_table = (struct hash_chain_entry **)
100: GC_generic_malloc_inner_ignore_off_page(
101: (size_t)new_size * sizeof(struct hash_chain_entry *), NORMAL);
102:
103: if (new_table == 0) {
104: if (table == 0) {
105: ABORT("Insufficient space for initial table allocation");
106: } else {
107: return;
108: }
109: }
110: for (i = 0; i < old_size; i++) {
111: p = (*table)[i];
112: while (p != 0) {
113: register ptr_t real_key = (ptr_t)REVEAL_POINTER(p -> hidden_key);
114: register struct hash_chain_entry *next = p -> next;
115: register int new_hash = HASH3(real_key, new_size, log_new_size);
116:
117: p -> next = new_table[new_hash];
118: new_table[new_hash] = p;
119: p = next;
120: }
121: }
122: *log_size_ptr = log_new_size;
123: *table = new_table;
124: }
125:
126: # if defined(__STDC__) || defined(__cplusplus)
127: int GC_register_disappearing_link(GC_PTR * link)
128: # else
129: int GC_register_disappearing_link(link)
130: GC_PTR * link;
131: # endif
132: {
133: ptr_t base;
134:
135: base = (ptr_t)GC_base((GC_PTR)link);
136: if (base == 0)
137: ABORT("Bad arg to GC_register_disappearing_link");
138: return(GC_general_register_disappearing_link(link, base));
139: }
140:
141: # if defined(__STDC__) || defined(__cplusplus)
142: int GC_general_register_disappearing_link(GC_PTR * link,
143: GC_PTR obj)
144: # else
145: int GC_general_register_disappearing_link(link, obj)
146: GC_PTR * link;
147: GC_PTR obj;
148: # endif
149:
150: {
151: struct disappearing_link *curr_dl;
152: int index;
153: struct disappearing_link * new_dl;
154: DCL_LOCK_STATE;
155:
156: if ((word)link & (ALIGNMENT-1))
157: ABORT("Bad arg to GC_general_register_disappearing_link");
158: # ifdef THREADS
159: DISABLE_SIGNALS();
160: LOCK();
161: # endif
162: if (log_dl_table_size == -1
163: || GC_dl_entries > ((word)1 << log_dl_table_size)) {
164: # ifndef THREADS
165: DISABLE_SIGNALS();
166: # endif
167: GC_grow_table((struct hash_chain_entry ***)(&dl_head),
168: &log_dl_table_size);
169: # ifdef PRINTSTATS
170: GC_printf1("Grew dl table to %lu entries\n",
171: (unsigned long)(1 << log_dl_table_size));
172: # endif
173: # ifndef THREADS
174: ENABLE_SIGNALS();
175: # endif
176: }
177: index = HASH2(link, log_dl_table_size);
178: curr_dl = dl_head[index];
179: for (curr_dl = dl_head[index]; curr_dl != 0; curr_dl = dl_next(curr_dl)) {
180: if (curr_dl -> dl_hidden_link == HIDE_POINTER(link)) {
181: curr_dl -> dl_hidden_obj = HIDE_POINTER(obj);
182: # ifdef THREADS
183: UNLOCK();
184: ENABLE_SIGNALS();
185: # endif
186: return(1);
187: }
188: }
189: # ifdef THREADS
190: new_dl = (struct disappearing_link *)
191: GC_generic_malloc_inner(sizeof(struct disappearing_link),NORMAL);
192: # else
193: new_dl = (struct disappearing_link *)
194: GC_malloc(sizeof(struct disappearing_link));
195: # endif
196: if (new_dl != 0) {
197: new_dl -> dl_hidden_obj = HIDE_POINTER(obj);
198: new_dl -> dl_hidden_link = HIDE_POINTER(link);
199: dl_set_next(new_dl, dl_head[index]);
200: dl_head[index] = new_dl;
201: GC_dl_entries++;
202: } else {
203: GC_finalization_failures++;
204: }
205: # ifdef THREADS
206: UNLOCK();
207: ENABLE_SIGNALS();
208: # endif
209: return(0);
210: }
211:
212: # if defined(__STDC__) || defined(__cplusplus)
213: int GC_unregister_disappearing_link(GC_PTR * link)
214: # else
215: int GC_unregister_disappearing_link(link)
216: GC_PTR * link;
217: # endif
218: {
219: struct disappearing_link *curr_dl, *prev_dl;
220: int index;
221: DCL_LOCK_STATE;
222:
223: DISABLE_SIGNALS();
224: LOCK();
225: index = HASH2(link, log_dl_table_size);
226: if (((unsigned long)link & (ALIGNMENT-1))) goto out;
227: prev_dl = 0; curr_dl = dl_head[index];
228: while (curr_dl != 0) {
229: if (curr_dl -> dl_hidden_link == HIDE_POINTER(link)) {
230: if (prev_dl == 0) {
231: dl_head[index] = dl_next(curr_dl);
232: } else {
233: dl_set_next(prev_dl, dl_next(curr_dl));
234: }
235: GC_dl_entries--;
236: UNLOCK();
237: ENABLE_SIGNALS();
238: GC_free((GC_PTR)curr_dl);
239: return(1);
240: }
241: prev_dl = curr_dl;
242: curr_dl = dl_next(curr_dl);
243: }
244: out:
245: UNLOCK();
246: ENABLE_SIGNALS();
247: return(0);
248: }
249:
250: /* Possible finalization_marker procedures. Note that mark stack */
251: /* overflow is handled by the caller, and is not a disaster. */
252: void GC_normal_finalize_mark_proc(p)
253: ptr_t p;
254: {
255: hdr * hhdr = HDR(p);
256:
257: PUSH_OBJ((word *)p, hhdr, GC_mark_stack_top,
258: &(GC_mark_stack[GC_mark_stack_size]));
259: }
260:
261: /* This only pays very partial attention to the mark descriptor. */
262: /* It does the right thing for normal and atomic objects, and treats */
263: /* most others as normal. */
264: void GC_ignore_self_finalize_mark_proc(p)
265: ptr_t p;
266: {
267: hdr * hhdr = HDR(p);
268: word descr = hhdr -> hb_descr;
269: ptr_t q, r;
270: ptr_t scan_limit;
271: ptr_t target_limit = p + WORDS_TO_BYTES(hhdr -> hb_sz) - 1;
272:
273: if ((descr & DS_TAGS) == DS_LENGTH) {
274: scan_limit = p + descr - sizeof(word);
275: } else {
276: scan_limit = target_limit + 1 - sizeof(word);
277: }
278: for (q = p; q <= scan_limit; q += ALIGNMENT) {
279: r = *(ptr_t *)q;
280: if (r < p || r > target_limit) {
281: GC_PUSH_ONE_HEAP((word)r, q);
282: }
283: }
284: }
285:
286: /*ARGSUSED*/
287: void GC_null_finalize_mark_proc(p)
288: ptr_t p;
289: {
290: }
291:
292:
293:
294: /* Register a finalization function. See gc.h for details. */
295: /* in the nonthreads case, we try to avoid disabling signals, */
296: /* since it can be expensive. Threads packages typically */
297: /* make it cheaper. */
298: void GC_register_finalizer_inner(obj, fn, cd, ofn, ocd, mp)
299: GC_PTR obj;
300: GC_finalization_proc fn;
301: GC_PTR cd;
302: GC_finalization_proc * ofn;
303: GC_PTR * ocd;
304: finalization_mark_proc * mp;
305: {
306: ptr_t base;
307: struct finalizable_object * curr_fo, * prev_fo;
308: int index;
309: struct finalizable_object *new_fo;
310: DCL_LOCK_STATE;
311:
312: # ifdef THREADS
313: DISABLE_SIGNALS();
314: LOCK();
315: # endif
316: if (log_fo_table_size == -1
317: || GC_fo_entries > ((word)1 << log_fo_table_size)) {
318: # ifndef THREADS
319: DISABLE_SIGNALS();
320: # endif
321: GC_grow_table((struct hash_chain_entry ***)(&fo_head),
322: &log_fo_table_size);
323: # ifdef PRINTSTATS
324: GC_printf1("Grew fo table to %lu entries\n",
325: (unsigned long)(1 << log_fo_table_size));
326: # endif
327: # ifndef THREADS
328: ENABLE_SIGNALS();
329: # endif
330: }
331: /* in the THREADS case signals are disabled and we hold allocation */
332: /* lock; otherwise neither is true. Proceed carefully. */
333: base = (ptr_t)obj;
334: index = HASH2(base, log_fo_table_size);
335: prev_fo = 0; curr_fo = fo_head[index];
336: while (curr_fo != 0) {
337: if (curr_fo -> fo_hidden_base == HIDE_POINTER(base)) {
338: /* Interruption by a signal in the middle of this */
339: /* should be safe. The client may see only *ocd */
340: /* updated, but we'll declare that to be his */
341: /* problem. */
342: if (ocd) *ocd = (GC_PTR) curr_fo -> fo_client_data;
343: if (ofn) *ofn = curr_fo -> fo_fn;
344: /* Delete the structure for base. */
345: if (prev_fo == 0) {
346: fo_head[index] = fo_next(curr_fo);
347: } else {
348: fo_set_next(prev_fo, fo_next(curr_fo));
349: }
350: if (fn == 0) {
351: GC_fo_entries--;
352: /* May not happen if we get a signal. But a high */
353: /* estimate will only make the table larger than */
354: /* necessary. */
355: # ifndef THREADS
356: GC_free((GC_PTR)curr_fo);
357: # endif
358: } else {
359: curr_fo -> fo_fn = fn;
360: curr_fo -> fo_client_data = (ptr_t)cd;
361: curr_fo -> fo_mark_proc = mp;
362: /* Reinsert it. We deleted it first to maintain */
363: /* consistency in the event of a signal. */
364: if (prev_fo == 0) {
365: fo_head[index] = curr_fo;
366: } else {
367: fo_set_next(prev_fo, curr_fo);
368: }
369: }
370: # ifdef THREADS
371: UNLOCK();
372: ENABLE_SIGNALS();
373: # endif
374: return;
375: }
376: prev_fo = curr_fo;
377: curr_fo = fo_next(curr_fo);
378: }
379: if (ofn) *ofn = 0;
380: if (ocd) *ocd = 0;
381: if (fn == 0) {
382: # ifdef THREADS
383: UNLOCK();
384: ENABLE_SIGNALS();
385: # endif
386: return;
387: }
388: # ifdef THREADS
389: new_fo = (struct finalizable_object *)
390: GC_generic_malloc_inner(sizeof(struct finalizable_object),NORMAL);
391: # else
392: new_fo = (struct finalizable_object *)
393: GC_malloc(sizeof(struct finalizable_object));
394: # endif
395: if (new_fo != 0) {
396: new_fo -> fo_hidden_base = (word)HIDE_POINTER(base);
397: new_fo -> fo_fn = fn;
398: new_fo -> fo_client_data = (ptr_t)cd;
399: new_fo -> fo_object_size = GC_size(base);
400: new_fo -> fo_mark_proc = mp;
401: fo_set_next(new_fo, fo_head[index]);
402: GC_fo_entries++;
403: fo_head[index] = new_fo;
404: } else {
405: GC_finalization_failures++;
406: }
407: # ifdef THREADS
408: UNLOCK();
409: ENABLE_SIGNALS();
410: # endif
411: }
412:
413: # if defined(__STDC__)
414: void GC_register_finalizer(void * obj,
415: GC_finalization_proc fn, void * cd,
416: GC_finalization_proc *ofn, void ** ocd)
417: # else
418: void GC_register_finalizer(obj, fn, cd, ofn, ocd)
419: GC_PTR obj;
420: GC_finalization_proc fn;
421: GC_PTR cd;
422: GC_finalization_proc * ofn;
423: GC_PTR * ocd;
424: # endif
425: {
426: GC_register_finalizer_inner(obj, fn, cd, ofn,
427: ocd, GC_normal_finalize_mark_proc);
428: }
429:
430: # if defined(__STDC__)
431: void GC_register_finalizer_ignore_self(void * obj,
432: GC_finalization_proc fn, void * cd,
433: GC_finalization_proc *ofn, void ** ocd)
434: # else
435: void GC_register_finalizer_ignore_self(obj, fn, cd, ofn, ocd)
436: GC_PTR obj;
437: GC_finalization_proc fn;
438: GC_PTR cd;
439: GC_finalization_proc * ofn;
440: GC_PTR * ocd;
441: # endif
442: {
443: GC_register_finalizer_inner(obj, fn, cd, ofn,
444: ocd, GC_ignore_self_finalize_mark_proc);
445: }
446:
447: # if defined(__STDC__)
448: void GC_register_finalizer_no_order(void * obj,
449: GC_finalization_proc fn, void * cd,
450: GC_finalization_proc *ofn, void ** ocd)
451: # else
452: void GC_register_finalizer_no_order(obj, fn, cd, ofn, ocd)
453: GC_PTR obj;
454: GC_finalization_proc fn;
455: GC_PTR cd;
456: GC_finalization_proc * ofn;
457: GC_PTR * ocd;
458: # endif
459: {
460: GC_register_finalizer_inner(obj, fn, cd, ofn,
461: ocd, GC_null_finalize_mark_proc);
462: }
463:
464: /* Called with world stopped. Cause disappearing links to disappear, */
465: /* and invoke finalizers. */
466: void GC_finalize()
467: {
468: struct disappearing_link * curr_dl, * prev_dl, * next_dl;
469: struct finalizable_object * curr_fo, * prev_fo, * next_fo;
470: ptr_t real_ptr, real_link;
471: register int i;
472: int dl_size = (log_dl_table_size == -1 ) ? 0 : (1 << log_dl_table_size);
473: int fo_size = (log_fo_table_size == -1 ) ? 0 : (1 << log_fo_table_size);
474:
475: /* Make disappearing links disappear */
476: for (i = 0; i < dl_size; i++) {
477: curr_dl = dl_head[i];
478: prev_dl = 0;
479: while (curr_dl != 0) {
480: real_ptr = (ptr_t)REVEAL_POINTER(curr_dl -> dl_hidden_obj);
481: real_link = (ptr_t)REVEAL_POINTER(curr_dl -> dl_hidden_link);
482: if (!GC_is_marked(real_ptr)) {
483: *(word *)real_link = 0;
484: next_dl = dl_next(curr_dl);
485: if (prev_dl == 0) {
486: dl_head[i] = next_dl;
487: } else {
488: dl_set_next(prev_dl, next_dl);
489: }
490: GC_clear_mark_bit((ptr_t)curr_dl);
491: GC_dl_entries--;
492: curr_dl = next_dl;
493: } else {
494: prev_dl = curr_dl;
495: curr_dl = dl_next(curr_dl);
496: }
497: }
498: }
499: /* Mark all objects reachable via chains of 1 or more pointers */
500: /* from finalizable objects. */
501: # ifdef PRINTSTATS
502: if (GC_mark_state != MS_NONE) ABORT("Bad mark state");
503: # endif
504: for (i = 0; i < fo_size; i++) {
505: for (curr_fo = fo_head[i]; curr_fo != 0; curr_fo = fo_next(curr_fo)) {
506: real_ptr = (ptr_t)REVEAL_POINTER(curr_fo -> fo_hidden_base);
507: if (!GC_is_marked(real_ptr)) {
508: GC_MARKED_FOR_FINALIZATION(real_ptr);
509: GC_MARK_FO(real_ptr, curr_fo -> fo_mark_proc);
510: if (GC_is_marked(real_ptr)) {
511: WARN("Finalization cycle involving %lx\n", real_ptr);
512: }
513: }
514: }
515: }
516: /* Enqueue for finalization all objects that are still */
517: /* unreachable. */
518: GC_words_finalized = 0;
519: for (i = 0; i < fo_size; i++) {
520: curr_fo = fo_head[i];
521: prev_fo = 0;
522: while (curr_fo != 0) {
523: real_ptr = (ptr_t)REVEAL_POINTER(curr_fo -> fo_hidden_base);
524: if (!GC_is_marked(real_ptr)) {
525: # ifndef JAVA_FINALIZATION
526: GC_set_mark_bit(real_ptr);
527: # endif
528: /* Delete from hash table */
529: next_fo = fo_next(curr_fo);
530: if (prev_fo == 0) {
531: fo_head[i] = next_fo;
532: } else {
533: fo_set_next(prev_fo, next_fo);
534: }
535: GC_fo_entries--;
536: /* Add to list of objects awaiting finalization. */
537: fo_set_next(curr_fo, GC_finalize_now);
538: GC_finalize_now = curr_fo;
539: /* unhide object pointer so any future collections will */
540: /* see it. */
541: curr_fo -> fo_hidden_base =
542: (word) REVEAL_POINTER(curr_fo -> fo_hidden_base);
543: GC_words_finalized +=
544: ALIGNED_WORDS(curr_fo -> fo_object_size)
545: + ALIGNED_WORDS(sizeof(struct finalizable_object));
546: # ifdef PRINTSTATS
547: if (!GC_is_marked((ptr_t)curr_fo)) {
548: ABORT("GC_finalize: found accessible unmarked object\n");
549: }
550: # endif
551: curr_fo = next_fo;
552: } else {
553: prev_fo = curr_fo;
554: curr_fo = fo_next(curr_fo);
555: }
556: }
557: }
558:
559: # ifdef JAVA_FINALIZATION
560: /* make sure we mark everything reachable from objects finalized
561: using the no_order mark_proc */
562: for (curr_fo = GC_finalize_now;
563: curr_fo != NULL; curr_fo = fo_next(curr_fo)) {
564: real_ptr = (ptr_t)curr_fo -> fo_hidden_base;
565: if (!GC_is_marked(real_ptr)) {
566: if (curr_fo -> fo_mark_proc == GC_null_finalize_mark_proc) {
567: GC_MARK_FO(real_ptr, GC_normal_finalize_mark_proc);
568: }
569: GC_set_mark_bit(real_ptr);
570: }
571: }
572: # endif
573:
574: /* Remove dangling disappearing links. */
575: for (i = 0; i < dl_size; i++) {
576: curr_dl = dl_head[i];
577: prev_dl = 0;
578: while (curr_dl != 0) {
579: real_link = GC_base((ptr_t)REVEAL_POINTER(curr_dl -> dl_hidden_link));
580: if (real_link != 0 && !GC_is_marked(real_link)) {
581: next_dl = dl_next(curr_dl);
582: if (prev_dl == 0) {
583: dl_head[i] = next_dl;
584: } else {
585: dl_set_next(prev_dl, next_dl);
586: }
587: GC_clear_mark_bit((ptr_t)curr_dl);
588: GC_dl_entries--;
589: curr_dl = next_dl;
590: } else {
591: prev_dl = curr_dl;
592: curr_dl = dl_next(curr_dl);
593: }
594: }
595: }
596: }
597:
598: #ifdef JAVA_FINALIZATION
599:
600: /* Enqueue all remaining finalizers to be run - Assumes lock is
601: * held, and signals are disabled */
602: void GC_enqueue_all_finalizers()
603: {
604: struct finalizable_object * curr_fo, * prev_fo, * next_fo;
605: ptr_t real_ptr, real_link;
606: register int i;
607: int fo_size;
608:
609: fo_size = (log_fo_table_size == -1 ) ? 0 : (1 << log_fo_table_size);
610: GC_words_finalized = 0;
611: for (i = 0; i < fo_size; i++) {
612: curr_fo = fo_head[i];
613: prev_fo = 0;
614: while (curr_fo != 0) {
615: real_ptr = (ptr_t)REVEAL_POINTER(curr_fo -> fo_hidden_base);
616: GC_MARK_FO(real_ptr, GC_normal_finalize_mark_proc);
617: GC_set_mark_bit(real_ptr);
618:
619: /* Delete from hash table */
620: next_fo = fo_next(curr_fo);
621: if (prev_fo == 0) {
622: fo_head[i] = next_fo;
623: } else {
624: fo_set_next(prev_fo, next_fo);
625: }
626: GC_fo_entries--;
627:
628: /* Add to list of objects awaiting finalization. */
629: fo_set_next(curr_fo, GC_finalize_now);
630: GC_finalize_now = curr_fo;
631:
632: /* unhide object pointer so any future collections will */
633: /* see it. */
634: curr_fo -> fo_hidden_base =
635: (word) REVEAL_POINTER(curr_fo -> fo_hidden_base);
636:
637: GC_words_finalized +=
638: ALIGNED_WORDS(curr_fo -> fo_object_size)
639: + ALIGNED_WORDS(sizeof(struct finalizable_object));
640: curr_fo = next_fo;
641: }
642: }
643:
644: return;
645: }
646:
647: /* Invoke all remaining finalizers that haven't yet been run.
648: * This is needed for strict compliance with the Java standard,
649: * which can make the runtime guarantee that all finalizers are run.
650: * Unfortunately, the Java standard implies we have to keep running
651: * finalizers until there are no more left, a potential infinite loop.
652: * YUCK.
653: * This routine is externally callable, so is called without
654: * the allocation lock.
655: */
656: void GC_finalize_all()
657: {
658: DCL_LOCK_STATE;
659:
660: DISABLE_SIGNALS();
661: LOCK();
662: while (GC_fo_entries > 0) {
663: GC_enqueue_all_finalizers();
664: UNLOCK();
665: ENABLE_SIGNALS();
666: GC_INVOKE_FINALIZERS();
667: DISABLE_SIGNALS();
668: LOCK();
669: }
670: UNLOCK();
671: ENABLE_SIGNALS();
672: }
673: #endif
674:
675: /* Invoke finalizers for all objects that are ready to be finalized. */
676: /* Should be called without allocation lock. */
677: int GC_invoke_finalizers()
678: {
679: register struct finalizable_object * curr_fo;
680: register int count = 0;
681: DCL_LOCK_STATE;
682:
683: while (GC_finalize_now != 0) {
684: # ifdef THREADS
685: DISABLE_SIGNALS();
686: LOCK();
687: # endif
688: curr_fo = GC_finalize_now;
689: # ifdef THREADS
690: if (curr_fo != 0) GC_finalize_now = fo_next(curr_fo);
691: UNLOCK();
692: ENABLE_SIGNALS();
693: if (curr_fo == 0) break;
694: # else
695: GC_finalize_now = fo_next(curr_fo);
696: # endif
697: fo_set_next(curr_fo, 0);
698: (*(curr_fo -> fo_fn))((ptr_t)(curr_fo -> fo_hidden_base),
699: curr_fo -> fo_client_data);
700: curr_fo -> fo_client_data = 0;
701: ++count;
702: # ifdef UNDEFINED
703: /* This is probably a bad idea. It throws off accounting if */
704: /* nearly all objects are finalizable. O.w. it shouldn't */
705: /* matter. */
706: GC_free((GC_PTR)curr_fo);
707: # endif
708: }
709: return count;
710: }
711:
712: # ifdef __STDC__
713: GC_PTR GC_call_with_alloc_lock(GC_fn_type fn,
714: GC_PTR client_data)
715: # else
716: GC_PTR GC_call_with_alloc_lock(fn, client_data)
717: GC_fn_type fn;
718: GC_PTR client_data;
719: # endif
720: {
721: GC_PTR result;
722: DCL_LOCK_STATE;
723:
724: # ifdef THREADS
725: DISABLE_SIGNALS();
726: LOCK();
727: SET_LOCK_HOLDER();
728: # endif
729: result = (*fn)(client_data);
730: # ifdef THREADS
731: UNSET_LOCK_HOLDER();
732: UNLOCK();
733: ENABLE_SIGNALS();
734: # endif
735: return(result);
736: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to finalize.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib2 / asir2000 / gc