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