Annotation of OpenXM_contrib2/asir2000/gc/allchblk.c, Revision 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: * Copyright (c) 1998-1999 by Silicon Graphics. All rights reserved.
! 5: *
! 6: * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
! 7: * OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
! 8: *
! 9: * Permission is hereby granted to use or copy this program
! 10: * for any purpose, provided the above notices are retained on all copies.
! 11: * Permission to modify the code and to distribute modified code is granted,
! 12: * provided the above notices are retained, and a notice that the code was
! 13: * modified is included with the above copyright notice.
! 14: */
! 15:
! 16: #define DEBUG
! 17: #undef DEBUG
! 18: #include <stdio.h>
! 19: #include "gc_priv.h"
! 20:
! 21:
! 22: /*
! 23: * Free heap blocks are kept on one of several free lists,
! 24: * depending on the size of the block. Each free list is doubly linked.
! 25: * Adjacent free blocks are coalesced.
! 26: */
! 27:
! 28:
! 29: # define MAX_BLACK_LIST_ALLOC (2*HBLKSIZE)
! 30: /* largest block we will allocate starting on a black */
! 31: /* listed block. Must be >= HBLKSIZE. */
! 32:
! 33:
! 34: # define UNIQUE_THRESHOLD 32
! 35: /* Sizes up to this many HBLKs each have their own free list */
! 36: # define HUGE_THRESHOLD 256
! 37: /* Sizes of at least this many heap blocks are mapped to a */
! 38: /* single free list. */
! 39: # define FL_COMPRESSION 8
! 40: /* In between sizes map this many distinct sizes to a single */
! 41: /* bin. */
! 42:
! 43: # define N_HBLK_FLS (HUGE_THRESHOLD - UNIQUE_THRESHOLD)/FL_COMPRESSION \
! 44: + UNIQUE_THRESHOLD
! 45:
! 46: struct hblk * GC_hblkfreelist[N_HBLK_FLS+1] = { 0 };
! 47:
! 48: /* Map a number of blocks to the appropriate large block free list index. */
! 49: int GC_hblk_fl_from_blocks(blocks_needed)
! 50: word blocks_needed;
! 51: {
! 52: if (blocks_needed <= UNIQUE_THRESHOLD) return blocks_needed;
! 53: if (blocks_needed >= HUGE_THRESHOLD) return N_HBLK_FLS;
! 54: return (blocks_needed - UNIQUE_THRESHOLD)/FL_COMPRESSION
! 55: + UNIQUE_THRESHOLD;
! 56:
! 57: }
! 58:
! 59: # define HBLK_IS_FREE(hdr) ((hdr) -> hb_map == GC_invalid_map)
! 60: # define PHDR(hhdr) HDR(hhdr -> hb_prev)
! 61: # define NHDR(hhdr) HDR(hhdr -> hb_next)
! 62:
! 63: # ifdef USE_MUNMAP
! 64: # define IS_MAPPED(hhdr) (((hhdr) -> hb_flags & WAS_UNMAPPED) == 0)
! 65: # else /* !USE_MMAP */
! 66: # define IS_MAPPED(hhdr) 1
! 67: # endif /* USE_MUNMAP */
! 68:
! 69: # if !defined(NO_DEBUGGING)
! 70: void GC_print_hblkfreelist()
! 71: {
! 72: struct hblk * h;
! 73: word total_free = 0;
! 74: hdr * hhdr;
! 75: word sz;
! 76: int i;
! 77:
! 78: for (i = 0; i <= N_HBLK_FLS; ++i) {
! 79: h = GC_hblkfreelist[i];
! 80: if (0 != h) GC_printf1("Free list %ld:\n", (unsigned long)i);
! 81: while (h != 0) {
! 82: hhdr = HDR(h);
! 83: sz = hhdr -> hb_sz;
! 84: GC_printf2("\t0x%lx size %lu ", (unsigned long)h, (unsigned long)sz);
! 85: total_free += sz;
! 86: if (GC_is_black_listed(h, HBLKSIZE) != 0) {
! 87: GC_printf0("start black listed\n");
! 88: } else if (GC_is_black_listed(h, hhdr -> hb_sz) != 0) {
! 89: GC_printf0("partially black listed\n");
! 90: } else {
! 91: GC_printf0("not black listed\n");
! 92: }
! 93: h = hhdr -> hb_next;
! 94: }
! 95: }
! 96: if (total_free != GC_large_free_bytes) {
! 97: GC_printf1("GC_large_free_bytes = %lu (INCONSISTENT!!)\n",
! 98: (unsigned long) GC_large_free_bytes);
! 99: }
! 100: GC_printf1("Total of %lu bytes on free list\n", (unsigned long)total_free);
! 101: }
! 102:
! 103: /* Return the free list index on which the block described by the header */
! 104: /* appears, or -1 if it appears nowhere. */
! 105: int free_list_index_of(wanted)
! 106: hdr * wanted;
! 107: {
! 108: struct hblk * h;
! 109: hdr * hhdr;
! 110: int i;
! 111:
! 112: for (i = 0; i <= N_HBLK_FLS; ++i) {
! 113: h = GC_hblkfreelist[i];
! 114: while (h != 0) {
! 115: hhdr = HDR(h);
! 116: if (hhdr == wanted) return i;
! 117: h = hhdr -> hb_next;
! 118: }
! 119: }
! 120: return -1;
! 121: }
! 122:
! 123: void GC_dump_regions()
! 124: {
! 125: int i;
! 126: ptr_t start, end;
! 127: ptr_t p;
! 128: size_t bytes;
! 129: hdr *hhdr;
! 130: for (i = 0; i < GC_n_heap_sects; ++i) {
! 131: start = GC_heap_sects[i].hs_start;
! 132: bytes = GC_heap_sects[i].hs_bytes;
! 133: end = start + bytes;
! 134: /* Merge in contiguous sections. */
! 135: while (i+1 < GC_n_heap_sects && GC_heap_sects[i+1].hs_start == end) {
! 136: ++i;
! 137: end = GC_heap_sects[i].hs_start + GC_heap_sects[i].hs_bytes;
! 138: }
! 139: GC_printf2("***Section from 0x%lx to 0x%lx\n", start, end);
! 140: for (p = start; p < end;) {
! 141: hhdr = HDR(p);
! 142: GC_printf1("\t0x%lx ", (unsigned long)p);
! 143: if (IS_FORWARDING_ADDR_OR_NIL(hhdr)) {
! 144: GC_printf1("Missing header!!\n", hhdr);
! 145: p += HBLKSIZE;
! 146: continue;
! 147: }
! 148: if (HBLK_IS_FREE(hhdr)) {
! 149: int correct_index = GC_hblk_fl_from_blocks(
! 150: divHBLKSZ(hhdr -> hb_sz));
! 151: int actual_index;
! 152:
! 153: GC_printf1("\tfree block of size 0x%lx bytes",
! 154: (unsigned long)(hhdr -> hb_sz));
! 155: if (IS_MAPPED(hhdr)) {
! 156: GC_printf0("\n");
! 157: } else {
! 158: GC_printf0("(unmapped)\n");
! 159: }
! 160: actual_index = free_list_index_of(hhdr);
! 161: if (-1 == actual_index) {
! 162: GC_printf1("\t\tBlock not on free list %ld!!\n",
! 163: correct_index);
! 164: } else if (correct_index != actual_index) {
! 165: GC_printf2("\t\tBlock on list %ld, should be on %ld!!\n",
! 166: actual_index, correct_index);
! 167: }
! 168: p += hhdr -> hb_sz;
! 169: } else {
! 170: GC_printf1("\tused for blocks of size 0x%lx bytes\n",
! 171: (unsigned long)WORDS_TO_BYTES(hhdr -> hb_sz));
! 172: p += HBLKSIZE * OBJ_SZ_TO_BLOCKS(hhdr -> hb_sz);
! 173: }
! 174: }
! 175: }
! 176: }
! 177:
! 178: # endif /* NO_DEBUGGING */
! 179:
! 180: /* Initialize hdr for a block containing the indicated size and */
! 181: /* kind of objects. */
! 182: /* Return FALSE on failure. */
! 183: static GC_bool setup_header(hhdr, sz, kind, flags)
! 184: register hdr * hhdr;
! 185: word sz; /* object size in words */
! 186: int kind;
! 187: unsigned char flags;
! 188: {
! 189: register word descr;
! 190:
! 191: /* Add description of valid object pointers */
! 192: if (!GC_add_map_entry(sz)) return(FALSE);
! 193: hhdr -> hb_map = GC_obj_map[sz > MAXOBJSZ? 0 : sz];
! 194:
! 195: /* Set size, kind and mark proc fields */
! 196: hhdr -> hb_sz = sz;
! 197: hhdr -> hb_obj_kind = kind;
! 198: hhdr -> hb_flags = flags;
! 199: descr = GC_obj_kinds[kind].ok_descriptor;
! 200: if (GC_obj_kinds[kind].ok_relocate_descr) descr += WORDS_TO_BYTES(sz);
! 201: hhdr -> hb_descr = descr;
! 202:
! 203: /* Clear mark bits */
! 204: GC_clear_hdr_marks(hhdr);
! 205:
! 206: hhdr -> hb_last_reclaimed = (unsigned short)GC_gc_no;
! 207: return(TRUE);
! 208: }
! 209:
! 210: #define FL_UNKNOWN -1
! 211: /*
! 212: * Remove hhdr from the appropriate free list.
! 213: * We assume it is on the nth free list, or on the size
! 214: * appropriate free list if n is FL_UNKNOWN.
! 215: */
! 216: void GC_remove_from_fl(hhdr, n)
! 217: hdr * hhdr;
! 218: int n;
! 219: {
! 220: GC_ASSERT(((hhdr -> hb_sz) & (HBLKSIZE-1)) == 0);
! 221: if (hhdr -> hb_prev == 0) {
! 222: int index;
! 223: if (FL_UNKNOWN == n) {
! 224: index = GC_hblk_fl_from_blocks(divHBLKSZ(hhdr -> hb_sz));
! 225: } else {
! 226: index = n;
! 227: }
! 228: GC_ASSERT(HDR(GC_hblkfreelist[index]) == hhdr);
! 229: GC_hblkfreelist[index] = hhdr -> hb_next;
! 230: } else {
! 231: PHDR(hhdr) -> hb_next = hhdr -> hb_next;
! 232: }
! 233: if (0 != hhdr -> hb_next) {
! 234: GC_ASSERT(!IS_FORWARDING_ADDR_OR_NIL(NHDR(hhdr)));
! 235: NHDR(hhdr) -> hb_prev = hhdr -> hb_prev;
! 236: }
! 237: }
! 238:
! 239: /*
! 240: * Return a pointer to the free block ending just before h, if any.
! 241: */
! 242: struct hblk * GC_free_block_ending_at(h)
! 243: struct hblk *h;
! 244: {
! 245: struct hblk * p = h - 1;
! 246: hdr * phdr = HDR(p);
! 247:
! 248: while (0 != phdr && IS_FORWARDING_ADDR_OR_NIL(phdr)) {
! 249: p = FORWARDED_ADDR(p,phdr);
! 250: phdr = HDR(p);
! 251: }
! 252: if (0 != phdr && HBLK_IS_FREE(phdr)) return p;
! 253: p = GC_prev_block(h - 1);
! 254: if (0 != p) {
! 255: phdr = HDR(p);
! 256: if (HBLK_IS_FREE(phdr) && (ptr_t)p + phdr -> hb_sz == (ptr_t)h) {
! 257: return p;
! 258: }
! 259: }
! 260: return 0;
! 261: }
! 262:
! 263: /*
! 264: * Add hhdr to the appropriate free list.
! 265: * We maintain individual free lists sorted by address.
! 266: */
! 267: void GC_add_to_fl(h, hhdr)
! 268: struct hblk *h;
! 269: hdr * hhdr;
! 270: {
! 271: int index = GC_hblk_fl_from_blocks(divHBLKSZ(hhdr -> hb_sz));
! 272: struct hblk *second = GC_hblkfreelist[index];
! 273: # ifdef GC_ASSERTIONS
! 274: struct hblk *next = (struct hblk *)((word)h + hhdr -> hb_sz);
! 275: hdr * nexthdr = HDR(next);
! 276: struct hblk *prev = GC_free_block_ending_at(h);
! 277: hdr * prevhdr = HDR(prev);
! 278: GC_ASSERT(nexthdr == 0 || !HBLK_IS_FREE(nexthdr) || !IS_MAPPED(nexthdr));
! 279: GC_ASSERT(prev == 0 || !HBLK_IS_FREE(prevhdr) || !IS_MAPPED(prevhdr));
! 280: # endif
! 281: GC_ASSERT(((hhdr -> hb_sz) & (HBLKSIZE-1)) == 0);
! 282: GC_hblkfreelist[index] = h;
! 283: hhdr -> hb_next = second;
! 284: hhdr -> hb_prev = 0;
! 285: if (0 != second) HDR(second) -> hb_prev = h;
! 286: GC_invalidate_map(hhdr);
! 287: }
! 288:
! 289: #ifdef USE_MUNMAP
! 290:
! 291: /* Unmap blocks that haven't been recently touched. This is the only way */
! 292: /* way blocks are ever unmapped. */
! 293: void GC_unmap_old(void)
! 294: {
! 295: struct hblk * h;
! 296: hdr * hhdr;
! 297: word sz;
! 298: unsigned short last_rec, threshold;
! 299: int i;
! 300: # define UNMAP_THRESHOLD 6
! 301:
! 302: for (i = 0; i <= N_HBLK_FLS; ++i) {
! 303: for (h = GC_hblkfreelist[i]; 0 != h; h = hhdr -> hb_next) {
! 304: hhdr = HDR(h);
! 305: if (!IS_MAPPED(hhdr)) continue;
! 306: threshold = (unsigned short)(GC_gc_no - UNMAP_THRESHOLD);
! 307: last_rec = hhdr -> hb_last_reclaimed;
! 308: if (last_rec > GC_gc_no
! 309: || last_rec < threshold && threshold < GC_gc_no
! 310: /* not recently wrapped */) {
! 311: sz = hhdr -> hb_sz;
! 312: GC_unmap((ptr_t)h, sz);
! 313: hhdr -> hb_flags |= WAS_UNMAPPED;
! 314: }
! 315: }
! 316: }
! 317: }
! 318:
! 319: /* Merge all unmapped blocks that are adjacent to other free */
! 320: /* blocks. This may involve remapping, since all blocks are either */
! 321: /* fully mapped or fully unmapped. */
! 322: void GC_merge_unmapped(void)
! 323: {
! 324: struct hblk * h, *next;
! 325: hdr * hhdr, *nexthdr;
! 326: word size, nextsize;
! 327: int i;
! 328:
! 329: for (i = 0; i <= N_HBLK_FLS; ++i) {
! 330: h = GC_hblkfreelist[i];
! 331: while (h != 0) {
! 332: hhdr = HDR(h);
! 333: size = hhdr->hb_sz;
! 334: next = (struct hblk *)((word)h + size);
! 335: nexthdr = HDR(next);
! 336: /* Coalesce with successor, if possible */
! 337: if (0 != nexthdr && HBLK_IS_FREE(nexthdr)) {
! 338: nextsize = nexthdr -> hb_sz;
! 339: if (IS_MAPPED(hhdr)) {
! 340: GC_ASSERT(!IS_MAPPED(nexthdr));
! 341: /* make both consistent, so that we can merge */
! 342: if (size > nextsize) {
! 343: GC_remap((ptr_t)next, nextsize);
! 344: } else {
! 345: GC_unmap((ptr_t)h, size);
! 346: hhdr -> hb_flags |= WAS_UNMAPPED;
! 347: }
! 348: } else if (IS_MAPPED(nexthdr)) {
! 349: GC_ASSERT(!IS_MAPPED(hhdr));
! 350: if (size > nextsize) {
! 351: GC_unmap((ptr_t)next, nextsize);
! 352: } else {
! 353: GC_remap((ptr_t)h, size);
! 354: hhdr -> hb_flags &= ~WAS_UNMAPPED;
! 355: }
! 356: } else {
! 357: /* Unmap any gap in the middle */
! 358: GC_unmap_gap((ptr_t)h, size, (ptr_t)next, nexthdr -> hb_sz);
! 359: }
! 360: /* If they are both unmapped, we merge, but leave unmapped. */
! 361: GC_remove_from_fl(hhdr, i);
! 362: GC_remove_from_fl(nexthdr, FL_UNKNOWN);
! 363: hhdr -> hb_sz += nexthdr -> hb_sz;
! 364: GC_remove_header(next);
! 365: GC_add_to_fl(h, hhdr);
! 366: /* Start over at beginning of list */
! 367: h = GC_hblkfreelist[i];
! 368: } else /* not mergable with successor */ {
! 369: h = hhdr -> hb_next;
! 370: }
! 371: } /* while (h != 0) ... */
! 372: } /* for ... */
! 373: }
! 374:
! 375: #endif /* USE_MUNMAP */
! 376:
! 377: /*
! 378: * Return a pointer to a block starting at h of length bytes.
! 379: * Memory for the block is mapped.
! 380: * Remove the block from its free list, and return the remainder (if any)
! 381: * to its appropriate free list.
! 382: * May fail by returning 0.
! 383: * The header for the returned block must be set up by the caller.
! 384: * If the return value is not 0, then hhdr is the header for it.
! 385: */
! 386: struct hblk * GC_get_first_part(h, hhdr, bytes, index)
! 387: struct hblk *h;
! 388: hdr * hhdr;
! 389: word bytes;
! 390: int index;
! 391: {
! 392: word total_size = hhdr -> hb_sz;
! 393: struct hblk * rest;
! 394: hdr * rest_hdr;
! 395:
! 396: GC_ASSERT((total_size & (HBLKSIZE-1)) == 0);
! 397: GC_remove_from_fl(hhdr, index);
! 398: if (total_size == bytes) return h;
! 399: rest = (struct hblk *)((word)h + bytes);
! 400: if (!GC_install_header(rest)) return(0);
! 401: rest_hdr = HDR(rest);
! 402: rest_hdr -> hb_sz = total_size - bytes;
! 403: rest_hdr -> hb_flags = 0;
! 404: # ifdef GC_ASSERTIONS
! 405: // Mark h not free, to avoid assertion about adjacent free blocks.
! 406: hhdr -> hb_map = 0;
! 407: # endif
! 408: GC_add_to_fl(rest, rest_hdr);
! 409: return h;
! 410: }
! 411:
! 412: /*
! 413: * H is a free block. N points at an address inside it.
! 414: * A new header for n has already been set up. Fix up h's header
! 415: * to reflect the fact that it is being split, move it to the
! 416: * appropriate free list.
! 417: * N replaces h in the original free list.
! 418: *
! 419: * Nhdr is not completely filled in, since it is about to allocated.
! 420: * It may in fact end up on the wrong free list for its size.
! 421: * (Hence adding it to a free list is silly. But this path is hopefully
! 422: * rare enough that it doesn't matter. The code is cleaner this way.)
! 423: */
! 424: void GC_split_block(h, hhdr, n, nhdr, index)
! 425: struct hblk *h;
! 426: hdr * hhdr;
! 427: struct hblk *n;
! 428: hdr * nhdr;
! 429: int index; /* Index of free list */
! 430: {
! 431: word total_size = hhdr -> hb_sz;
! 432: word h_size = (word)n - (word)h;
! 433: struct hblk *prev = hhdr -> hb_prev;
! 434: struct hblk *next = hhdr -> hb_next;
! 435:
! 436: /* Replace h with n on its freelist */
! 437: nhdr -> hb_prev = prev;
! 438: nhdr -> hb_next = next;
! 439: nhdr -> hb_sz = total_size - h_size;
! 440: nhdr -> hb_flags = 0;
! 441: if (0 != prev) {
! 442: HDR(prev) -> hb_next = n;
! 443: } else {
! 444: GC_hblkfreelist[index] = n;
! 445: }
! 446: if (0 != next) {
! 447: HDR(next) -> hb_prev = n;
! 448: }
! 449: # ifdef GC_ASSERTIONS
! 450: nhdr -> hb_map = 0; /* Don't fail test for consecutive */
! 451: /* free blocks in GC_add_to_fl. */
! 452: # endif
! 453: # ifdef USE_MUNMAP
! 454: hhdr -> hb_last_reclaimed = GC_gc_no;
! 455: # endif
! 456: hhdr -> hb_sz = h_size;
! 457: GC_add_to_fl(h, hhdr);
! 458: GC_invalidate_map(nhdr);
! 459: }
! 460:
! 461: struct hblk * GC_allochblk_nth();
! 462:
! 463: /*
! 464: * Allocate (and return pointer to) a heap block
! 465: * for objects of size sz words, searching the nth free list.
! 466: *
! 467: * NOTE: We set obj_map field in header correctly.
! 468: * Caller is responsible for building an object freelist in block.
! 469: *
! 470: * We clear the block if it is destined for large objects, and if
! 471: * kind requires that newly allocated objects be cleared.
! 472: */
! 473: struct hblk *
! 474: GC_allochblk(sz, kind, flags)
! 475: word sz;
! 476: int kind;
! 477: unsigned char flags; /* IGNORE_OFF_PAGE or 0 */
! 478: {
! 479: int start_list = GC_hblk_fl_from_blocks(OBJ_SZ_TO_BLOCKS(sz));
! 480: int i;
! 481: for (i = start_list; i <= N_HBLK_FLS; ++i) {
! 482: struct hblk * result = GC_allochblk_nth(sz, kind, flags, i);
! 483: if (0 != result) return result;
! 484: }
! 485: return 0;
! 486: }
! 487: /*
! 488: * The same, but with search restricted to nth free list.
! 489: */
! 490: struct hblk *
! 491: GC_allochblk_nth(sz, kind, flags, n)
! 492: word sz;
! 493: int kind;
! 494: unsigned char flags; /* IGNORE_OFF_PAGE or 0 */
! 495: int n;
! 496: {
! 497: register struct hblk *hbp;
! 498: register hdr * hhdr; /* Header corr. to hbp */
! 499: register struct hblk *thishbp;
! 500: register hdr * thishdr; /* Header corr. to hbp */
! 501: signed_word size_needed; /* number of bytes in requested objects */
! 502: signed_word size_avail; /* bytes available in this block */
! 503:
! 504: size_needed = HBLKSIZE * OBJ_SZ_TO_BLOCKS(sz);
! 505:
! 506: /* search for a big enough block in free list */
! 507: hbp = GC_hblkfreelist[n];
! 508: hhdr = HDR(hbp);
! 509: for(; 0 != hbp; hbp = hhdr -> hb_next, hhdr = HDR(hbp)) {
! 510: size_avail = hhdr->hb_sz;
! 511: if (size_avail < size_needed) continue;
! 512: # ifdef PRESERVE_LAST
! 513: if (size_avail != size_needed
! 514: && !GC_incremental && GC_should_collect()) {
! 515: continue;
! 516: }
! 517: # endif
! 518: /* If the next heap block is obviously better, go on. */
! 519: /* This prevents us from disassembling a single large block */
! 520: /* to get tiny blocks. */
! 521: {
! 522: signed_word next_size;
! 523:
! 524: thishbp = hhdr -> hb_next;
! 525: if (thishbp != 0) {
! 526: thishdr = HDR(thishbp);
! 527: next_size = (signed_word)(thishdr -> hb_sz);
! 528: if (next_size < size_avail
! 529: && next_size >= size_needed
! 530: && !GC_is_black_listed(thishbp, (word)size_needed)) {
! 531: continue;
! 532: }
! 533: }
! 534: }
! 535: if ( !IS_UNCOLLECTABLE(kind) &&
! 536: (kind != PTRFREE || size_needed > MAX_BLACK_LIST_ALLOC)) {
! 537: struct hblk * lasthbp = hbp;
! 538: ptr_t search_end = (ptr_t)hbp + size_avail - size_needed;
! 539: signed_word orig_avail = size_avail;
! 540: signed_word eff_size_needed = ((flags & IGNORE_OFF_PAGE)?
! 541: HBLKSIZE
! 542: : size_needed);
! 543:
! 544:
! 545: while ((ptr_t)lasthbp <= search_end
! 546: && (thishbp = GC_is_black_listed(lasthbp,
! 547: (word)eff_size_needed))) {
! 548: lasthbp = thishbp;
! 549: }
! 550: size_avail -= (ptr_t)lasthbp - (ptr_t)hbp;
! 551: thishbp = lasthbp;
! 552: if (size_avail >= size_needed) {
! 553: if (thishbp != hbp && GC_install_header(thishbp)) {
! 554: /* Make sure it's mapped before we mangle it. */
! 555: # ifdef USE_MUNMAP
! 556: if (!IS_MAPPED(hhdr)) {
! 557: GC_remap((ptr_t)hbp, size_avail);
! 558: hhdr -> hb_flags &= ~WAS_UNMAPPED;
! 559: }
! 560: # endif
! 561: /* Split the block at thishbp */
! 562: thishdr = HDR(thishbp);
! 563: GC_split_block(hbp, hhdr, thishbp, thishdr, n);
! 564: /* Advance to thishbp */
! 565: hbp = thishbp;
! 566: hhdr = thishdr;
! 567: /* We must now allocate thishbp, since it may */
! 568: /* be on the wrong free list. */
! 569: }
! 570: } else if (size_needed > (signed_word)BL_LIMIT
! 571: && orig_avail - size_needed
! 572: > (signed_word)BL_LIMIT) {
! 573: /* Punt, since anything else risks unreasonable heap growth. */
! 574: WARN("Needed to allocate blacklisted block at 0x%lx\n",
! 575: (word)hbp);
! 576: size_avail = orig_avail;
! 577: } else if (size_avail == 0 && size_needed == HBLKSIZE
! 578: && IS_MAPPED(hhdr)) {
! 579: # ifndef FIND_LEAK
! 580: static unsigned count = 0;
! 581:
! 582: /* The block is completely blacklisted. We need */
! 583: /* to drop some such blocks, since otherwise we spend */
! 584: /* all our time traversing them if pointerfree */
! 585: /* blocks are unpopular. */
! 586: /* A dropped block will be reconsidered at next GC. */
! 587: if ((++count & 3) == 0) {
! 588: /* Allocate and drop the block in small chunks, to */
! 589: /* maximize the chance that we will recover some */
! 590: /* later. */
! 591: word total_size = hhdr -> hb_sz;
! 592: struct hblk * limit = hbp + divHBLKSZ(total_size);
! 593: struct hblk * h;
! 594: struct hblk * prev = hhdr -> hb_prev;
! 595:
! 596: GC_words_wasted += total_size;
! 597: GC_large_free_bytes -= total_size;
! 598: GC_remove_from_fl(hhdr, n);
! 599: for (h = hbp; h < limit; h++) {
! 600: if (h == hbp || GC_install_header(h)) {
! 601: hhdr = HDR(h);
! 602: (void) setup_header(
! 603: hhdr,
! 604: BYTES_TO_WORDS(HBLKSIZE - HDR_BYTES),
! 605: PTRFREE, 0); /* Cant fail */
! 606: if (GC_debugging_started) {
! 607: BZERO(h + HDR_BYTES, HBLKSIZE - HDR_BYTES);
! 608: }
! 609: }
! 610: }
! 611: /* Restore hbp to point at free block */
! 612: hbp = prev;
! 613: if (0 == hbp) {
! 614: return GC_allochblk_nth(sz, kind, flags, n);
! 615: }
! 616: hhdr = HDR(hbp);
! 617: }
! 618: # endif
! 619: }
! 620: }
! 621: if( size_avail >= size_needed ) {
! 622: # ifdef USE_MUNMAP
! 623: if (!IS_MAPPED(hhdr)) {
! 624: GC_remap((ptr_t)hbp, size_avail);
! 625: hhdr -> hb_flags &= ~WAS_UNMAPPED;
! 626: }
! 627: # endif
! 628: /* hbp may be on the wrong freelist; the parameter n */
! 629: /* is important. */
! 630: hbp = GC_get_first_part(hbp, hhdr, size_needed, n);
! 631: break;
! 632: }
! 633: }
! 634:
! 635: if (0 == hbp) return 0;
! 636:
! 637: /* Notify virtual dirty bit implementation that we are about to write. */
! 638: GC_write_hint(hbp);
! 639:
! 640: /* Add it to map of valid blocks */
! 641: if (!GC_install_counts(hbp, (word)size_needed)) return(0);
! 642: /* This leaks memory under very rare conditions. */
! 643:
! 644: /* Set up header */
! 645: if (!setup_header(hhdr, sz, kind, flags)) {
! 646: GC_remove_counts(hbp, (word)size_needed);
! 647: return(0); /* ditto */
! 648: }
! 649:
! 650: /* Clear block if necessary */
! 651: if (GC_debugging_started
! 652: || sz > MAXOBJSZ && GC_obj_kinds[kind].ok_init) {
! 653: BZERO(hbp + HDR_BYTES, size_needed - HDR_BYTES);
! 654: }
! 655:
! 656: /* We just successfully allocated a block. Restart count of */
! 657: /* consecutive failures. */
! 658: {
! 659: extern unsigned GC_fail_count;
! 660:
! 661: GC_fail_count = 0;
! 662: }
! 663:
! 664: GC_large_free_bytes -= size_needed;
! 665:
! 666: GC_ASSERT(IS_MAPPED(hhdr));
! 667: return( hbp );
! 668: }
! 669:
! 670: struct hblk * GC_freehblk_ptr = 0; /* Search position hint for GC_freehblk */
! 671:
! 672: /*
! 673: * Free a heap block.
! 674: *
! 675: * Coalesce the block with its neighbors if possible.
! 676: *
! 677: * All mark words are assumed to be cleared.
! 678: */
! 679: void
! 680: GC_freehblk(hbp)
! 681: struct hblk *hbp;
! 682: {
! 683: struct hblk *next, *prev;
! 684: hdr *hhdr, *prevhdr, *nexthdr;
! 685: signed_word size;
! 686:
! 687:
! 688: hhdr = HDR(hbp);
! 689: size = hhdr->hb_sz;
! 690: size = HBLKSIZE * OBJ_SZ_TO_BLOCKS(size);
! 691: GC_remove_counts(hbp, (word)size);
! 692: hhdr->hb_sz = size;
! 693:
! 694: /* Check for duplicate deallocation in the easy case */
! 695: if (HBLK_IS_FREE(hhdr)) {
! 696: GC_printf1("Duplicate large block deallocation of 0x%lx\n",
! 697: (unsigned long) hbp);
! 698: }
! 699:
! 700: GC_ASSERT(IS_MAPPED(hhdr));
! 701: GC_invalidate_map(hhdr);
! 702: next = (struct hblk *)((word)hbp + size);
! 703: nexthdr = HDR(next);
! 704: prev = GC_free_block_ending_at(hbp);
! 705: /* Coalesce with successor, if possible */
! 706: if(0 != nexthdr && HBLK_IS_FREE(nexthdr) && IS_MAPPED(nexthdr)) {
! 707: GC_remove_from_fl(nexthdr, FL_UNKNOWN);
! 708: hhdr -> hb_sz += nexthdr -> hb_sz;
! 709: GC_remove_header(next);
! 710: }
! 711: /* Coalesce with predecessor, if possible. */
! 712: if (0 != prev) {
! 713: prevhdr = HDR(prev);
! 714: if (IS_MAPPED(prevhdr)) {
! 715: GC_remove_from_fl(prevhdr, FL_UNKNOWN);
! 716: prevhdr -> hb_sz += hhdr -> hb_sz;
! 717: GC_remove_header(hbp);
! 718: hbp = prev;
! 719: hhdr = prevhdr;
! 720: }
! 721: }
! 722:
! 723: GC_large_free_bytes += size;
! 724: GC_add_to_fl(hbp, hhdr);
! 725: }
! 726:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to allchblk.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib2 / asir2000 / gc