Annotation of OpenXM_contrib2/asir2000/gc/reclaim.c, Revision 1.1.1.1
1.1 noro 1: /*
2: * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
3: * Copyright (c) 1991-1994 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 15, 1996 2:41 pm PST */
15:
16: #include <stdio.h>
17: #include "gc_priv.h"
18:
19: void GC_timerstart(), GC_timerstop();
20:
21: signed_word GC_mem_found = 0;
22: /* Number of words of memory reclaimed */
23:
24: # ifdef FIND_LEAK
25: static void report_leak(p, sz)
26: ptr_t p;
27: word sz;
28: {
29: if (HDR(p) -> hb_obj_kind == PTRFREE) {
30: GC_err_printf0("Leaked atomic object at ");
31: } else {
32: GC_err_printf0("Leaked composite object at ");
33: }
34: if (GC_debugging_started && GC_has_debug_info(p)) {
35: GC_print_obj(p);
36: } else {
37: GC_err_printf2("0x%lx (appr. size = %ld)\n",
38: (unsigned long)p,
39: (unsigned long)WORDS_TO_BYTES(sz));
40: }
41: }
42:
43: # define FOUND_FREE(hblk, word_no) \
44: if (abort_if_found) { \
45: report_leak((ptr_t)hblk + WORDS_TO_BYTES(word_no), \
46: HDR(hblk) -> hb_sz); \
47: }
48: # else
49: # define FOUND_FREE(hblk, word_no)
50: # endif
51:
52: /*
53: * reclaim phase
54: *
55: */
56:
57:
58: /*
59: * Test whether a block is completely empty, i.e. contains no marked
60: * objects. This does not require the block to be in physical
61: * memory.
62: */
63:
64: GC_bool GC_block_empty(hhdr)
65: register hdr * hhdr;
66: {
67: register word *p = (word *)(&(hhdr -> hb_marks[0]));
68: register word * plim =
69: (word *)(&(hhdr -> hb_marks[MARK_BITS_SZ]));
70: while (p < plim) {
71: if (*p++) return(FALSE);
72: }
73: return(TRUE);
74: }
75:
76: # ifdef GATHERSTATS
77: # define INCR_WORDS(sz) n_words_found += (sz)
78: # else
79: # define INCR_WORDS(sz)
80: # endif
81: /*
82: * Restore unmarked small objects in h of size sz to the object
83: * free list. Returns the new list.
84: * Clears unmarked objects.
85: */
86: /*ARGSUSED*/
87: ptr_t GC_reclaim_clear(hbp, hhdr, sz, list, abort_if_found)
88: register struct hblk *hbp; /* ptr to current heap block */
89: register hdr * hhdr;
90: GC_bool abort_if_found; /* Abort if a reclaimable object is found */
91: register ptr_t list;
92: register word sz;
93: {
94: register int word_no;
95: register word *p, *q, *plim;
96: # ifdef GATHERSTATS
97: register int n_words_found = 0;
98: # endif
99:
100: p = (word *)(hbp->hb_body);
101: word_no = HDR_WORDS;
102: plim = (word *)((((word)hbp) + HBLKSIZE)
103: - WORDS_TO_BYTES(sz));
104:
105: /* go through all words in block */
106: while( p <= plim ) {
107: if( mark_bit_from_hdr(hhdr, word_no) ) {
108: p += sz;
109: } else {
110: FOUND_FREE(hbp, word_no);
111: INCR_WORDS(sz);
112: /* object is available - put on list */
113: obj_link(p) = list;
114: list = ((ptr_t)p);
115: /* Clear object, advance p to next object in the process */
116: q = p + sz;
117: p++; /* Skip link field */
118: while (p < q) {
119: *p++ = 0;
120: }
121: }
122: word_no += sz;
123: }
124: # ifdef GATHERSTATS
125: GC_mem_found += n_words_found;
126: # endif
127: return(list);
128: }
129:
130: #ifndef SMALL_CONFIG
131:
132: /*
133: * A special case for 2 word composite objects (e.g. cons cells):
134: */
135: /*ARGSUSED*/
136: ptr_t GC_reclaim_clear2(hbp, hhdr, list, abort_if_found)
137: register struct hblk *hbp; /* ptr to current heap block */
138: hdr * hhdr;
139: GC_bool abort_if_found; /* Abort if a reclaimable object is found */
140: register ptr_t list;
141: {
142: register word * mark_word_addr = &(hhdr->hb_marks[divWORDSZ(HDR_WORDS)]);
143: register word *p, *plim;
144: # ifdef GATHERSTATS
145: register int n_words_found = 0;
146: # endif
147: register word mark_word;
148: register int i;
149: # define DO_OBJ(start_displ) \
150: if (!(mark_word & ((word)1 << start_displ))) { \
151: FOUND_FREE(hbp, p - (word *)hbp + start_displ); \
152: p[start_displ] = (word)list; \
153: list = (ptr_t)(p+start_displ); \
154: p[start_displ+1] = 0; \
155: INCR_WORDS(2); \
156: }
157:
158: p = (word *)(hbp->hb_body);
159: plim = (word *)(((word)hbp) + HBLKSIZE);
160:
161: /* go through all words in block */
162: while( p < plim ) {
163: mark_word = *mark_word_addr++;
164: for (i = 0; i < WORDSZ; i += 8) {
165: DO_OBJ(0);
166: DO_OBJ(2);
167: DO_OBJ(4);
168: DO_OBJ(6);
169: p += 8;
170: mark_word >>= 8;
171: }
172: }
173: # ifdef GATHERSTATS
174: GC_mem_found += n_words_found;
175: # endif
176: return(list);
177: # undef DO_OBJ
178: }
179:
180: /*
181: * Another special case for 4 word composite objects:
182: */
183: /*ARGSUSED*/
184: ptr_t GC_reclaim_clear4(hbp, hhdr, list, abort_if_found)
185: register struct hblk *hbp; /* ptr to current heap block */
186: hdr * hhdr;
187: GC_bool abort_if_found; /* Abort if a reclaimable object is found */
188: register ptr_t list;
189: {
190: register word * mark_word_addr = &(hhdr->hb_marks[divWORDSZ(HDR_WORDS)]);
191: register word *p, *plim;
192: # ifdef GATHERSTATS
193: register int n_words_found = 0;
194: # endif
195: register word mark_word;
196: # define DO_OBJ(start_displ) \
197: if (!(mark_word & ((word)1 << start_displ))) { \
198: FOUND_FREE(hbp, p - (word *)hbp + start_displ); \
199: p[start_displ] = (word)list; \
200: list = (ptr_t)(p+start_displ); \
201: p[start_displ+1] = 0; \
202: p[start_displ+2] = 0; \
203: p[start_displ+3] = 0; \
204: INCR_WORDS(4); \
205: }
206:
207: p = (word *)(hbp->hb_body);
208: plim = (word *)(((word)hbp) + HBLKSIZE);
209:
210: /* go through all words in block */
211: while( p < plim ) {
212: mark_word = *mark_word_addr++;
213: DO_OBJ(0);
214: DO_OBJ(4);
215: DO_OBJ(8);
216: DO_OBJ(12);
217: DO_OBJ(16);
218: DO_OBJ(20);
219: DO_OBJ(24);
220: DO_OBJ(28);
221: # if CPP_WORDSZ == 64
222: DO_OBJ(32);
223: DO_OBJ(36);
224: DO_OBJ(40);
225: DO_OBJ(44);
226: DO_OBJ(48);
227: DO_OBJ(52);
228: DO_OBJ(56);
229: DO_OBJ(60);
230: # endif
231: p += WORDSZ;
232: }
233: # ifdef GATHERSTATS
234: GC_mem_found += n_words_found;
235: # endif
236: return(list);
237: # undef DO_OBJ
238: }
239:
240: #endif /* !SMALL_CONFIG */
241:
242: /* The same thing, but don't clear objects: */
243: /*ARGSUSED*/
244: ptr_t GC_reclaim_uninit(hbp, hhdr, sz, list, abort_if_found)
245: register struct hblk *hbp; /* ptr to current heap block */
246: register hdr * hhdr;
247: GC_bool abort_if_found; /* Abort if a reclaimable object is found */
248: register ptr_t list;
249: register word sz;
250: {
251: register int word_no;
252: register word *p, *plim;
253: # ifdef GATHERSTATS
254: register int n_words_found = 0;
255: # endif
256:
257: p = (word *)(hbp->hb_body);
258: word_no = HDR_WORDS;
259: plim = (word *)((((word)hbp) + HBLKSIZE)
260: - WORDS_TO_BYTES(sz));
261:
262: /* go through all words in block */
263: while( p <= plim ) {
264: if( !mark_bit_from_hdr(hhdr, word_no) ) {
265: FOUND_FREE(hbp, word_no);
266: INCR_WORDS(sz);
267: /* object is available - put on list */
268: obj_link(p) = list;
269: list = ((ptr_t)p);
270: }
271: p += sz;
272: word_no += sz;
273: }
274: # ifdef GATHERSTATS
275: GC_mem_found += n_words_found;
276: # endif
277: return(list);
278: }
279:
280: #ifndef SMALL_CONFIG
281: /*
282: * Another special case for 2 word atomic objects:
283: */
284: /*ARGSUSED*/
285: ptr_t GC_reclaim_uninit2(hbp, hhdr, list, abort_if_found)
286: register struct hblk *hbp; /* ptr to current heap block */
287: hdr * hhdr;
288: GC_bool abort_if_found; /* Abort if a reclaimable object is found */
289: register ptr_t list;
290: {
291: register word * mark_word_addr = &(hhdr->hb_marks[divWORDSZ(HDR_WORDS)]);
292: register word *p, *plim;
293: # ifdef GATHERSTATS
294: register int n_words_found = 0;
295: # endif
296: register word mark_word;
297: register int i;
298: # define DO_OBJ(start_displ) \
299: if (!(mark_word & ((word)1 << start_displ))) { \
300: FOUND_FREE(hbp, p - (word *)hbp + start_displ); \
301: p[start_displ] = (word)list; \
302: list = (ptr_t)(p+start_displ); \
303: INCR_WORDS(2); \
304: }
305:
306: p = (word *)(hbp->hb_body);
307: plim = (word *)(((word)hbp) + HBLKSIZE);
308:
309: /* go through all words in block */
310: while( p < plim ) {
311: mark_word = *mark_word_addr++;
312: for (i = 0; i < WORDSZ; i += 8) {
313: DO_OBJ(0);
314: DO_OBJ(2);
315: DO_OBJ(4);
316: DO_OBJ(6);
317: p += 8;
318: mark_word >>= 8;
319: }
320: }
321: # ifdef GATHERSTATS
322: GC_mem_found += n_words_found;
323: # endif
324: return(list);
325: # undef DO_OBJ
326: }
327:
328: /*
329: * Another special case for 4 word atomic objects:
330: */
331: /*ARGSUSED*/
332: ptr_t GC_reclaim_uninit4(hbp, hhdr, list, abort_if_found)
333: register struct hblk *hbp; /* ptr to current heap block */
334: hdr * hhdr;
335: GC_bool abort_if_found; /* Abort if a reclaimable object is found */
336: register ptr_t list;
337: {
338: register word * mark_word_addr = &(hhdr->hb_marks[divWORDSZ(HDR_WORDS)]);
339: register word *p, *plim;
340: # ifdef GATHERSTATS
341: register int n_words_found = 0;
342: # endif
343: register word mark_word;
344: # define DO_OBJ(start_displ) \
345: if (!(mark_word & ((word)1 << start_displ))) { \
346: FOUND_FREE(hbp, p - (word *)hbp + start_displ); \
347: p[start_displ] = (word)list; \
348: list = (ptr_t)(p+start_displ); \
349: INCR_WORDS(4); \
350: }
351:
352: p = (word *)(hbp->hb_body);
353: plim = (word *)(((word)hbp) + HBLKSIZE);
354:
355: /* go through all words in block */
356: while( p < plim ) {
357: mark_word = *mark_word_addr++;
358: DO_OBJ(0);
359: DO_OBJ(4);
360: DO_OBJ(8);
361: DO_OBJ(12);
362: DO_OBJ(16);
363: DO_OBJ(20);
364: DO_OBJ(24);
365: DO_OBJ(28);
366: # if CPP_WORDSZ == 64
367: DO_OBJ(32);
368: DO_OBJ(36);
369: DO_OBJ(40);
370: DO_OBJ(44);
371: DO_OBJ(48);
372: DO_OBJ(52);
373: DO_OBJ(56);
374: DO_OBJ(60);
375: # endif
376: p += WORDSZ;
377: }
378: # ifdef GATHERSTATS
379: GC_mem_found += n_words_found;
380: # endif
381: return(list);
382: # undef DO_OBJ
383: }
384:
385: /* Finally the one word case, which never requires any clearing: */
386: /*ARGSUSED*/
387: ptr_t GC_reclaim1(hbp, hhdr, list, abort_if_found)
388: register struct hblk *hbp; /* ptr to current heap block */
389: hdr * hhdr;
390: GC_bool abort_if_found; /* Abort if a reclaimable object is found */
391: register ptr_t list;
392: {
393: register word * mark_word_addr = &(hhdr->hb_marks[divWORDSZ(HDR_WORDS)]);
394: register word *p, *plim;
395: # ifdef GATHERSTATS
396: register int n_words_found = 0;
397: # endif
398: register word mark_word;
399: register int i;
400: # define DO_OBJ(start_displ) \
401: if (!(mark_word & ((word)1 << start_displ))) { \
402: FOUND_FREE(hbp, p - (word *)hbp + start_displ); \
403: p[start_displ] = (word)list; \
404: list = (ptr_t)(p+start_displ); \
405: INCR_WORDS(1); \
406: }
407:
408: p = (word *)(hbp->hb_body);
409: plim = (word *)(((word)hbp) + HBLKSIZE);
410:
411: /* go through all words in block */
412: while( p < plim ) {
413: mark_word = *mark_word_addr++;
414: for (i = 0; i < WORDSZ; i += 4) {
415: DO_OBJ(0);
416: DO_OBJ(1);
417: DO_OBJ(2);
418: DO_OBJ(3);
419: p += 4;
420: mark_word >>= 4;
421: }
422: }
423: # ifdef GATHERSTATS
424: GC_mem_found += n_words_found;
425: # endif
426: return(list);
427: # undef DO_OBJ
428: }
429:
430: #endif /* !SMALL_CONFIG */
431:
432: /*
433: * Restore unmarked small objects in the block pointed to by hbp
434: * to the appropriate object free list.
435: * If entirely empty blocks are to be completely deallocated, then
436: * caller should perform that check.
437: */
438: void GC_reclaim_small_nonempty_block(hbp, abort_if_found)
439: register struct hblk *hbp; /* ptr to current heap block */
440: int abort_if_found; /* Abort if a reclaimable object is found */
441: {
442: hdr * hhdr;
443: register word sz; /* size of objects in current block */
444: register struct obj_kind * ok;
445: register ptr_t * flh;
446: register int kind;
447:
448: hhdr = HDR(hbp);
449: sz = hhdr -> hb_sz;
450: hhdr -> hb_last_reclaimed = (unsigned short) GC_gc_no;
451: kind = hhdr -> hb_obj_kind;
452: ok = &GC_obj_kinds[kind];
453: flh = &(ok -> ok_freelist[sz]);
454: GC_write_hint(hbp);
455:
456: if (ok -> ok_init) {
457: switch(sz) {
458: # ifndef SMALL_CONFIG
459: case 1:
460: *flh = GC_reclaim1(hbp, hhdr, *flh, abort_if_found);
461: break;
462: case 2:
463: *flh = GC_reclaim_clear2(hbp, hhdr, *flh, abort_if_found);
464: break;
465: case 4:
466: *flh = GC_reclaim_clear4(hbp, hhdr, *flh, abort_if_found);
467: break;
468: # endif
469: default:
470: *flh = GC_reclaim_clear(hbp, hhdr, sz, *flh, abort_if_found);
471: break;
472: }
473: } else {
474: switch(sz) {
475: # ifndef SMALL_CONFIG
476: case 1:
477: *flh = GC_reclaim1(hbp, hhdr, *flh, abort_if_found);
478: break;
479: case 2:
480: *flh = GC_reclaim_uninit2(hbp, hhdr, *flh, abort_if_found);
481: break;
482: case 4:
483: *flh = GC_reclaim_uninit4(hbp, hhdr, *flh, abort_if_found);
484: break;
485: # endif
486: default:
487: *flh = GC_reclaim_uninit(hbp, hhdr, sz, *flh, abort_if_found);
488: break;
489: }
490: }
491: if (IS_UNCOLLECTABLE(kind)) GC_set_hdr_marks(hhdr);
492: }
493:
494: /*
495: * Restore an unmarked large object or an entirely empty blocks of small objects
496: * to the heap block free list.
497: * Otherwise enqueue the block for later processing
498: * by GC_reclaim_small_nonempty_block.
499: * If abort_if_found is TRUE, then process any block immediately.
500: */
501: void GC_reclaim_block(hbp, abort_if_found)
502: register struct hblk *hbp; /* ptr to current heap block */
503: word abort_if_found; /* Abort if a reclaimable object is found */
504: {
505: register hdr * hhdr;
506: register word sz; /* size of objects in current block */
507: register struct obj_kind * ok;
508: struct hblk ** rlh;
509:
510: hhdr = HDR(hbp);
511: sz = hhdr -> hb_sz;
512: ok = &GC_obj_kinds[hhdr -> hb_obj_kind];
513:
514: if( sz > MAXOBJSZ ) { /* 1 big object */
515: if( !mark_bit_from_hdr(hhdr, HDR_WORDS) ) {
516: FOUND_FREE(hbp, HDR_WORDS);
517: # ifdef GATHERSTATS
518: GC_mem_found += sz;
519: # endif
520: GC_freehblk(hbp);
521: }
522: } else {
523: GC_bool empty = GC_block_empty(hhdr);
524: if (abort_if_found) {
525: GC_reclaim_small_nonempty_block(hbp, (int)abort_if_found);
526: } else if (empty) {
527: # ifdef GATHERSTATS
528: GC_mem_found += BYTES_TO_WORDS(HBLKSIZE);
529: # endif
530: GC_freehblk(hbp);
531: } else {
532: /* group of smaller objects, enqueue the real work */
533: rlh = &(ok -> ok_reclaim_list[sz]);
534: hhdr -> hb_next = *rlh;
535: *rlh = hbp;
536: }
537: }
538: }
539:
540: #if !defined(NO_DEBUGGING)
541: /* Routines to gather and print heap block info */
542: /* intended for debugging. Otherwise should be called */
543: /* with lock. */
544: static size_t number_of_blocks;
545: static size_t total_bytes;
546:
547: /* Number of set bits in a word. Not performance critical. */
548: static int set_bits(n)
549: word n;
550: {
551: register word m = n;
552: register int result = 0;
553:
554: while (m > 0) {
555: if (m & 1) result++;
556: m >>= 1;
557: }
558: return(result);
559: }
560:
561: /* Return the number of set mark bits in the given header */
562: int GC_n_set_marks(hhdr)
563: hdr * hhdr;
564: {
565: register int result = 0;
566: register int i;
567:
568: for (i = 0; i < MARK_BITS_SZ; i++) {
569: result += set_bits(hhdr -> hb_marks[i]);
570: }
571: return(result);
572: }
573:
574: /*ARGSUSED*/
575: void GC_print_block_descr(h, dummy)
576: struct hblk *h;
577: word dummy;
578: {
579: register hdr * hhdr = HDR(h);
580: register size_t bytes = WORDS_TO_BYTES(hhdr -> hb_sz);
581:
582: GC_printf3("(%lu:%lu,%lu)", (unsigned long)(hhdr -> hb_obj_kind),
583: (unsigned long)bytes,
584: (unsigned long)(GC_n_set_marks(hhdr)));
585: bytes += HDR_BYTES + HBLKSIZE-1;
586: bytes &= ~(HBLKSIZE-1);
587: total_bytes += bytes;
588: number_of_blocks++;
589: }
590:
591: void GC_print_block_list()
592: {
593: GC_printf0("(kind(0=ptrfree,1=normal,2=unc.,3=stubborn):size_in_bytes, #_marks_set)\n");
594: number_of_blocks = 0;
595: total_bytes = 0;
596: GC_apply_to_all_blocks(GC_print_block_descr, (word)0);
597: GC_printf2("\nblocks = %lu, bytes = %lu\n",
598: (unsigned long)number_of_blocks,
599: (unsigned long)total_bytes);
600: }
601:
602: #endif /* NO_DEBUGGING */
603:
604: /*
605: * Do the same thing on the entire heap, after first clearing small object
606: * free lists (if we are not just looking for leaks).
607: */
608: void GC_start_reclaim(abort_if_found)
609: int abort_if_found; /* Abort if a GC_reclaimable object is found */
610: {
611: int kind;
612:
613: /* Clear reclaim- and free-lists */
614: for (kind = 0; kind < GC_n_kinds; kind++) {
615: register ptr_t *fop;
616: register ptr_t *lim;
617: register struct hblk ** rlp;
618: register struct hblk ** rlim;
619: register struct hblk ** rlist = GC_obj_kinds[kind].ok_reclaim_list;
620:
621: if (rlist == 0) continue; /* This kind not used. */
622: if (!abort_if_found) {
623: lim = &(GC_obj_kinds[kind].ok_freelist[MAXOBJSZ+1]);
624: for( fop = GC_obj_kinds[kind].ok_freelist; fop < lim; fop++ ) {
625: *fop = 0;
626: }
627: } /* otherwise free list objects are marked, */
628: /* and its safe to leave them */
629: rlim = rlist + MAXOBJSZ+1;
630: for( rlp = rlist; rlp < rlim; rlp++ ) {
631: *rlp = 0;
632: }
633: }
634:
635: # ifdef PRINTBLOCKS
636: GC_printf0("GC_reclaim: current block sizes:\n");
637: GC_print_block_list();
638: # endif
639:
640: /* Go through all heap blocks (in hblklist) and reclaim unmarked objects */
641: /* or enqueue the block for later processing. */
642: GC_apply_to_all_blocks(GC_reclaim_block, (word)abort_if_found);
643:
644: }
645:
646: /*
647: * Sweep blocks of the indicated object size and kind until either the
648: * appropriate free list is nonempty, or there are no more blocks to
649: * sweep.
650: */
651: void GC_continue_reclaim(sz, kind)
652: word sz; /* words */
653: int kind;
654: {
655: register hdr * hhdr;
656: register struct hblk * hbp;
657: register struct obj_kind * ok = &(GC_obj_kinds[kind]);
658: struct hblk ** rlh = ok -> ok_reclaim_list;
659: ptr_t *flh = &(ok -> ok_freelist[sz]);
660:
661: if (rlh == 0) return; /* No blocks of this kind. */
662: rlh += sz;
663: GC_timerstart();
664: while ((hbp = *rlh) != 0) {
665: hhdr = HDR(hbp);
666: *rlh = hhdr -> hb_next;
667: GC_reclaim_small_nonempty_block(hbp, FALSE);
668: if (*flh != 0) break;
669: }
670: GC_timerstop();
671: }
672:
673: /*
674: * Reclaim all small blocks waiting to be reclaimed.
675: * Abort and return FALSE when/if (*stop_func)() returns TRUE.
676: * If this returns TRUE, then it's safe to restart the world
677: * with incorrectly cleared mark bits.
678: * If ignore_old is TRUE, then reclain only blocks that have been
679: * recently reclaimed, and discard the rest.
680: * Stop_func may be 0.
681: */
682: GC_bool GC_reclaim_all(stop_func, ignore_old)
683: GC_stop_func stop_func;
684: GC_bool ignore_old;
685: {
686: register word sz;
687: register int kind;
688: register hdr * hhdr;
689: register struct hblk * hbp;
690: register struct obj_kind * ok;
691: struct hblk ** rlp;
692: struct hblk ** rlh;
693: # ifdef PRINTTIMES
694: CLOCK_TYPE start_time;
695: CLOCK_TYPE done_time;
696:
697: GET_TIME(start_time);
698: # endif
699:
700: GC_timerstart();
701: for (kind = 0; kind < GC_n_kinds; kind++) {
702: ok = &(GC_obj_kinds[kind]);
703: rlp = ok -> ok_reclaim_list;
704: if (rlp == 0) continue;
705: for (sz = 1; sz <= MAXOBJSZ; sz++) {
706: rlh = rlp + sz;
707: while ((hbp = *rlh) != 0) {
708: if (stop_func != (GC_stop_func)0 && (*stop_func)()) {
709: return(FALSE);
710: }
711: hhdr = HDR(hbp);
712: *rlh = hhdr -> hb_next;
713: if (!ignore_old || hhdr -> hb_last_reclaimed == GC_gc_no - 1) {
714: /* It's likely we'll need it this time, too */
715: /* It's been touched recently, so this */
716: /* shouldn't trigger paging. */
717: GC_reclaim_small_nonempty_block(hbp, FALSE);
718: }
719: }
720: }
721: }
722: GC_timerstop();
723: # ifdef PRINTTIMES
724: GET_TIME(done_time);
725: GC_printf1("Disposing of reclaim lists took %lu msecs\n",
726: MS_TIME_DIFF(done_time,start_time));
727: # endif
728: return(TRUE);
729: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to reclaim.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib2 / asir2000 / gc