Annotation of OpenXM_contrib2/asir2000/gc5.3/malloc.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: *
! 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 7, 1996 4:32 pm PST */
! 15:
! 16: #include <stdio.h>
! 17: #include "gc_priv.h"
! 18:
! 19: extern ptr_t GC_clear_stack(); /* in misc.c, behaves like identity */
! 20: void GC_extend_size_map(); /* in misc.c. */
! 21:
! 22: /* Allocate reclaim list for kind: */
! 23: /* Return TRUE on success */
! 24: GC_bool GC_alloc_reclaim_list(kind)
! 25: register struct obj_kind * kind;
! 26: {
! 27: struct hblk ** result = (struct hblk **)
! 28: GC_scratch_alloc((MAXOBJSZ+1) * sizeof(struct hblk *));
! 29: if (result == 0) return(FALSE);
! 30: BZERO(result, (MAXOBJSZ+1)*sizeof(struct hblk *));
! 31: kind -> ok_reclaim_list = result;
! 32: return(TRUE);
! 33: }
! 34:
! 35: /* allocate lb bytes for an object of kind. */
! 36: /* Should not be used to directly to allocate */
! 37: /* objects such as STUBBORN objects that */
! 38: /* require special handling on allocation. */
! 39: /* First a version that assumes we already */
! 40: /* hold lock: */
! 41: ptr_t GC_generic_malloc_inner(lb, k)
! 42: register word lb;
! 43: register int k;
! 44: {
! 45: register word lw;
! 46: register ptr_t op;
! 47: register ptr_t *opp;
! 48:
! 49: if( SMALL_OBJ(lb) ) {
! 50: register struct obj_kind * kind = GC_obj_kinds + k;
! 51: # ifdef MERGE_SIZES
! 52: lw = GC_size_map[lb];
! 53: # else
! 54: lw = ALIGNED_WORDS(lb);
! 55: if (lw == 0) lw = 1;
! 56: # endif
! 57: opp = &(kind -> ok_freelist[lw]);
! 58: if( (op = *opp) == 0 ) {
! 59: # ifdef MERGE_SIZES
! 60: if (GC_size_map[lb] == 0) {
! 61: if (!GC_is_initialized) GC_init_inner();
! 62: if (GC_size_map[lb] == 0) GC_extend_size_map(lb);
! 63: return(GC_generic_malloc_inner(lb, k));
! 64: }
! 65: # else
! 66: if (!GC_is_initialized) {
! 67: GC_init_inner();
! 68: return(GC_generic_malloc_inner(lb, k));
! 69: }
! 70: # endif
! 71: if (kind -> ok_reclaim_list == 0) {
! 72: if (!GC_alloc_reclaim_list(kind)) goto out;
! 73: }
! 74: op = GC_allocobj(lw, k);
! 75: if (op == 0) goto out;
! 76: }
! 77: /* Here everything is in a consistent state. */
! 78: /* We assume the following assignment is */
! 79: /* atomic. If we get aborted */
! 80: /* after the assignment, we lose an object, */
! 81: /* but that's benign. */
! 82: /* Volatile declarations may need to be added */
! 83: /* to prevent the compiler from breaking things.*/
! 84: /* If we only execute the second of the */
! 85: /* following assignments, we lose the free */
! 86: /* list, but that should still be OK, at least */
! 87: /* for garbage collected memory. */
! 88: *opp = obj_link(op);
! 89: obj_link(op) = 0;
! 90: } else {
! 91: register struct hblk * h;
! 92: register word n_blocks = divHBLKSZ(ADD_SLOP(lb)
! 93: + HDR_BYTES + HBLKSIZE-1);
! 94:
! 95: if (!GC_is_initialized) GC_init_inner();
! 96: /* Do our share of marking work */
! 97: if(GC_incremental && !GC_dont_gc)
! 98: GC_collect_a_little_inner((int)n_blocks);
! 99: lw = ROUNDED_UP_WORDS(lb);
! 100: h = GC_allochblk(lw, k, 0);
! 101: # ifdef USE_MUNMAP
! 102: if (0 == h) {
! 103: GC_merge_unmapped();
! 104: h = GC_allochblk(lw, k, 0);
! 105: }
! 106: # endif
! 107: while (0 == h && GC_collect_or_expand(n_blocks, FALSE)) {
! 108: h = GC_allochblk(lw, k, 0);
! 109: }
! 110: if (h == 0) {
! 111: op = 0;
! 112: } else {
! 113: op = (ptr_t) (h -> hb_body);
! 114: GC_words_wasted += BYTES_TO_WORDS(n_blocks * HBLKSIZE) - lw;
! 115: }
! 116: }
! 117: GC_words_allocd += lw;
! 118:
! 119: out:
! 120: return((ptr_t)op);
! 121: }
! 122:
! 123: ptr_t GC_generic_malloc(lb, k)
! 124: register word lb;
! 125: register int k;
! 126: {
! 127: ptr_t result;
! 128: DCL_LOCK_STATE;
! 129:
! 130: GC_INVOKE_FINALIZERS();
! 131: DISABLE_SIGNALS();
! 132: LOCK();
! 133: result = GC_generic_malloc_inner(lb, k);
! 134: UNLOCK();
! 135: ENABLE_SIGNALS();
! 136: if (0 == result) {
! 137: return((*GC_oom_fn)(lb));
! 138: } else {
! 139: return(result);
! 140: }
! 141: }
! 142:
! 143:
! 144: #define GENERAL_MALLOC(lb,k) \
! 145: (GC_PTR)GC_clear_stack(GC_generic_malloc((word)lb, k))
! 146: /* We make the GC_clear_stack_call a tail call, hoping to get more of */
! 147: /* the stack. */
! 148:
! 149: /* Allocate lb bytes of atomic (pointerfree) data */
! 150: # ifdef __STDC__
! 151: GC_PTR GC_malloc_atomic(size_t lb)
! 152: # else
! 153: GC_PTR GC_malloc_atomic(lb)
! 154: size_t lb;
! 155: # endif
! 156: {
! 157: register ptr_t op;
! 158: register ptr_t * opp;
! 159: register word lw;
! 160: DCL_LOCK_STATE;
! 161:
! 162: if( SMALL_OBJ(lb) ) {
! 163: # ifdef MERGE_SIZES
! 164: lw = GC_size_map[lb];
! 165: # else
! 166: lw = ALIGNED_WORDS(lb);
! 167: # endif
! 168: opp = &(GC_aobjfreelist[lw]);
! 169: FASTLOCK();
! 170: if( !FASTLOCK_SUCCEEDED() || (op = *opp) == 0 ) {
! 171: FASTUNLOCK();
! 172: return(GENERAL_MALLOC((word)lb, PTRFREE));
! 173: }
! 174: /* See above comment on signals. */
! 175: *opp = obj_link(op);
! 176: GC_words_allocd += lw;
! 177: FASTUNLOCK();
! 178: return((GC_PTR) op);
! 179: } else {
! 180: return(GENERAL_MALLOC((word)lb, PTRFREE));
! 181: }
! 182: }
! 183:
! 184: /* Allocate lb bytes of composite (pointerful) data */
! 185: # ifdef __STDC__
! 186: GC_PTR GC_malloc(size_t lb)
! 187: # else
! 188: GC_PTR GC_malloc(lb)
! 189: size_t lb;
! 190: # endif
! 191: {
! 192: register ptr_t op;
! 193: register ptr_t *opp;
! 194: register word lw;
! 195: DCL_LOCK_STATE;
! 196:
! 197: if( SMALL_OBJ(lb) ) {
! 198: # ifdef MERGE_SIZES
! 199: lw = GC_size_map[lb];
! 200: # else
! 201: lw = ALIGNED_WORDS(lb);
! 202: # endif
! 203: opp = &(GC_objfreelist[lw]);
! 204: FASTLOCK();
! 205: if( !FASTLOCK_SUCCEEDED() || (op = *opp) == 0 ) {
! 206: FASTUNLOCK();
! 207: return(GENERAL_MALLOC((word)lb, NORMAL));
! 208: }
! 209: /* See above comment on signals. */
! 210: *opp = obj_link(op);
! 211: obj_link(op) = 0;
! 212: GC_words_allocd += lw;
! 213: FASTUNLOCK();
! 214: return((GC_PTR) op);
! 215: } else {
! 216: return(GENERAL_MALLOC((word)lb, NORMAL));
! 217: }
! 218: }
! 219:
! 220: # ifdef REDIRECT_MALLOC
! 221: # ifdef __STDC__
! 222: GC_PTR malloc(size_t lb)
! 223: # else
! 224: GC_PTR malloc(lb)
! 225: size_t lb;
! 226: # endif
! 227: {
! 228: /* It might help to manually inline the GC_malloc call here. */
! 229: /* But any decent compiler should reduce the extra procedure call */
! 230: /* to at most a jump instruction in this case. */
! 231: # if defined(I386) && defined(SOLARIS_THREADS)
! 232: /*
! 233: * Thread initialisation can call malloc before
! 234: * we're ready for it.
! 235: * It's not clear that this is enough to help matters.
! 236: * The thread implementation may well call malloc at other
! 237: * inopportune times.
! 238: */
! 239: if (!GC_is_initialized) return sbrk(lb);
! 240: # endif /* I386 && SOLARIS_THREADS */
! 241: return(REDIRECT_MALLOC(lb));
! 242: }
! 243:
! 244: # ifdef __STDC__
! 245: GC_PTR calloc(size_t n, size_t lb)
! 246: # else
! 247: GC_PTR calloc(n, lb)
! 248: size_t n, lb;
! 249: # endif
! 250: {
! 251: return(REDIRECT_MALLOC(n*lb));
! 252: }
! 253: # endif /* REDIRECT_MALLOC */
! 254:
! 255: GC_PTR GC_generic_or_special_malloc(lb,knd)
! 256: word lb;
! 257: int knd;
! 258: {
! 259: switch(knd) {
! 260: # ifdef STUBBORN_ALLOC
! 261: case STUBBORN:
! 262: return(GC_malloc_stubborn((size_t)lb));
! 263: # endif
! 264: case PTRFREE:
! 265: return(GC_malloc_atomic((size_t)lb));
! 266: case NORMAL:
! 267: return(GC_malloc((size_t)lb));
! 268: case UNCOLLECTABLE:
! 269: return(GC_malloc_uncollectable((size_t)lb));
! 270: # ifdef ATOMIC_UNCOLLECTABLE
! 271: case AUNCOLLECTABLE:
! 272: return(GC_malloc_atomic_uncollectable((size_t)lb));
! 273: # endif /* ATOMIC_UNCOLLECTABLE */
! 274: default:
! 275: return(GC_generic_malloc(lb,knd));
! 276: }
! 277: }
! 278:
! 279:
! 280: /* Change the size of the block pointed to by p to contain at least */
! 281: /* lb bytes. The object may be (and quite likely will be) moved. */
! 282: /* The kind (e.g. atomic) is the same as that of the old. */
! 283: /* Shrinking of large blocks is not implemented well. */
! 284: # ifdef __STDC__
! 285: GC_PTR GC_realloc(GC_PTR p, size_t lb)
! 286: # else
! 287: GC_PTR GC_realloc(p,lb)
! 288: GC_PTR p;
! 289: size_t lb;
! 290: # endif
! 291: {
! 292: register struct hblk * h;
! 293: register hdr * hhdr;
! 294: register word sz; /* Current size in bytes */
! 295: register word orig_sz; /* Original sz in bytes */
! 296: int obj_kind;
! 297:
! 298: if (p == 0) return(GC_malloc(lb)); /* Required by ANSI */
! 299: h = HBLKPTR(p);
! 300: hhdr = HDR(h);
! 301: sz = hhdr -> hb_sz;
! 302: obj_kind = hhdr -> hb_obj_kind;
! 303: sz = WORDS_TO_BYTES(sz);
! 304: orig_sz = sz;
! 305:
! 306: if (sz > WORDS_TO_BYTES(MAXOBJSZ)) {
! 307: /* Round it up to the next whole heap block */
! 308: register word descr;
! 309:
! 310: sz = (sz+HDR_BYTES+HBLKSIZE-1)
! 311: & (~HBLKMASK);
! 312: sz -= HDR_BYTES;
! 313: hhdr -> hb_sz = BYTES_TO_WORDS(sz);
! 314: descr = GC_obj_kinds[obj_kind].ok_descriptor;
! 315: if (GC_obj_kinds[obj_kind].ok_relocate_descr) descr += sz;
! 316: hhdr -> hb_descr = descr;
! 317: if (IS_UNCOLLECTABLE(obj_kind)) GC_non_gc_bytes += (sz - orig_sz);
! 318: /* Extra area is already cleared by allochblk. */
! 319: }
! 320: if (ADD_SLOP(lb) <= sz) {
! 321: if (lb >= (sz >> 1)) {
! 322: # ifdef STUBBORN_ALLOC
! 323: if (obj_kind == STUBBORN) GC_change_stubborn(p);
! 324: # endif
! 325: if (orig_sz > lb) {
! 326: /* Clear unneeded part of object to avoid bogus pointer */
! 327: /* tracing. */
! 328: /* Safe for stubborn objects. */
! 329: BZERO(((ptr_t)p) + lb, orig_sz - lb);
! 330: }
! 331: return(p);
! 332: } else {
! 333: /* shrink */
! 334: GC_PTR result =
! 335: GC_generic_or_special_malloc((word)lb, obj_kind);
! 336:
! 337: if (result == 0) return(0);
! 338: /* Could also return original object. But this */
! 339: /* gives the client warning of imminent disaster. */
! 340: BCOPY(p, result, lb);
! 341: # ifndef IGNORE_FREE
! 342: GC_free(p);
! 343: # endif
! 344: return(result);
! 345: }
! 346: } else {
! 347: /* grow */
! 348: GC_PTR result =
! 349: GC_generic_or_special_malloc((word)lb, obj_kind);
! 350:
! 351: if (result == 0) return(0);
! 352: BCOPY(p, result, sz);
! 353: # ifndef IGNORE_FREE
! 354: GC_free(p);
! 355: # endif
! 356: return(result);
! 357: }
! 358: }
! 359:
! 360: # ifdef REDIRECT_MALLOC
! 361: # ifdef __STDC__
! 362: GC_PTR realloc(GC_PTR p, size_t lb)
! 363: # else
! 364: GC_PTR realloc(p,lb)
! 365: GC_PTR p;
! 366: size_t lb;
! 367: # endif
! 368: {
! 369: return(GC_realloc(p, lb));
! 370: }
! 371: # endif /* REDIRECT_MALLOC */
! 372:
! 373: /* Explicitly deallocate an object p. */
! 374: # ifdef __STDC__
! 375: void GC_free(GC_PTR p)
! 376: # else
! 377: void GC_free(p)
! 378: GC_PTR p;
! 379: # endif
! 380: {
! 381: register struct hblk *h;
! 382: register hdr *hhdr;
! 383: register signed_word sz;
! 384: register ptr_t * flh;
! 385: register int knd;
! 386: register struct obj_kind * ok;
! 387: DCL_LOCK_STATE;
! 388:
! 389: if (p == 0) return;
! 390: /* Required by ANSI. It's not my fault ... */
! 391: h = HBLKPTR(p);
! 392: hhdr = HDR(h);
! 393: # if defined(REDIRECT_MALLOC) && \
! 394: (defined(SOLARIS_THREADS) || defined(LINUX_THREADS))
! 395: /* We have to redirect malloc calls during initialization. */
! 396: /* Don't try to deallocate that memory. */
! 397: if (0 == hhdr) return;
! 398: # endif
! 399: knd = hhdr -> hb_obj_kind;
! 400: sz = hhdr -> hb_sz;
! 401: ok = &GC_obj_kinds[knd];
! 402: if (sz <= MAXOBJSZ) {
! 403: # ifdef THREADS
! 404: DISABLE_SIGNALS();
! 405: LOCK();
! 406: # endif
! 407: GC_mem_freed += sz;
! 408: /* A signal here can make GC_mem_freed and GC_non_gc_bytes */
! 409: /* inconsistent. We claim this is benign. */
! 410: if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= WORDS_TO_BYTES(sz);
! 411: /* Its unnecessary to clear the mark bit. If the */
! 412: /* object is reallocated, it doesn't matter. O.w. the */
! 413: /* collector will do it, since it's on a free list. */
! 414: if (ok -> ok_init) {
! 415: BZERO((word *)p + 1, WORDS_TO_BYTES(sz-1));
! 416: }
! 417: flh = &(ok -> ok_freelist[sz]);
! 418: obj_link(p) = *flh;
! 419: *flh = (ptr_t)p;
! 420: # ifdef THREADS
! 421: UNLOCK();
! 422: ENABLE_SIGNALS();
! 423: # endif
! 424: } else {
! 425: DISABLE_SIGNALS();
! 426: LOCK();
! 427: GC_mem_freed += sz;
! 428: if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= WORDS_TO_BYTES(sz);
! 429: GC_freehblk(h);
! 430: UNLOCK();
! 431: ENABLE_SIGNALS();
! 432: }
! 433: }
! 434:
! 435: # ifdef REDIRECT_MALLOC
! 436: # ifdef __STDC__
! 437: void free(GC_PTR p)
! 438: # else
! 439: void free(p)
! 440: GC_PTR p;
! 441: # endif
! 442: {
! 443: # ifndef IGNORE_FREE
! 444: GC_free(p);
! 445: # endif
! 446: }
! 447: # endif /* REDIRECT_MALLOC */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to malloc.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib2 / asir2000 / gc5.3