Annotation of OpenXM_contrib/gc/new_hblk.c, Revision 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: * This file contains the functions:
! 15: * ptr_t GC_build_flXXX(h, old_fl)
! 16: * void GC_new_hblk(n)
! 17: */
! 18: /* Boehm, May 19, 1994 2:09 pm PDT */
! 19:
! 20:
! 21: # include <stdio.h>
! 22: # include "gc_priv.h"
! 23:
! 24: #ifndef SMALL_CONFIG
! 25: /*
! 26: * Build a free list for size 1 objects inside hblk h. Set the last link to
! 27: * be ofl. Return a pointer tpo the first free list entry.
! 28: */
! 29: ptr_t GC_build_fl1(h, ofl)
! 30: struct hblk *h;
! 31: ptr_t ofl;
! 32: {
! 33: register word * p = (word *)h;
! 34: register word * lim = (word *)(h + 1);
! 35:
! 36: p[0] = (word)ofl;
! 37: p[1] = (word)(p);
! 38: p[2] = (word)(p+1);
! 39: p[3] = (word)(p+2);
! 40: p += 4;
! 41: for (; p < lim; p += 4) {
! 42: p[0] = (word)(p-1);
! 43: p[1] = (word)(p);
! 44: p[2] = (word)(p+1);
! 45: p[3] = (word)(p+2);
! 46: };
! 47: return((ptr_t)(p-1));
! 48: }
! 49:
! 50: /* The same for size 2 cleared objects */
! 51: ptr_t GC_build_fl_clear2(h, ofl)
! 52: struct hblk *h;
! 53: ptr_t ofl;
! 54: {
! 55: register word * p = (word *)h;
! 56: register word * lim = (word *)(h + 1);
! 57:
! 58: p[0] = (word)ofl;
! 59: p[1] = 0;
! 60: p[2] = (word)p;
! 61: p[3] = 0;
! 62: p += 4;
! 63: for (; p < lim; p += 4) {
! 64: p[0] = (word)(p-2);
! 65: p[1] = 0;
! 66: p[2] = (word)p;
! 67: p[3] = 0;
! 68: };
! 69: return((ptr_t)(p-2));
! 70: }
! 71:
! 72: /* The same for size 3 cleared objects */
! 73: ptr_t GC_build_fl_clear3(h, ofl)
! 74: struct hblk *h;
! 75: ptr_t ofl;
! 76: {
! 77: register word * p = (word *)h;
! 78: register word * lim = (word *)(h + 1) - 2;
! 79:
! 80: p[0] = (word)ofl;
! 81: p[1] = 0;
! 82: p[2] = 0;
! 83: p += 3;
! 84: for (; p < lim; p += 3) {
! 85: p[0] = (word)(p-3);
! 86: p[1] = 0;
! 87: p[2] = 0;
! 88: };
! 89: return((ptr_t)(p-3));
! 90: }
! 91:
! 92: /* The same for size 4 cleared objects */
! 93: ptr_t GC_build_fl_clear4(h, ofl)
! 94: struct hblk *h;
! 95: ptr_t ofl;
! 96: {
! 97: register word * p = (word *)h;
! 98: register word * lim = (word *)(h + 1);
! 99:
! 100: p[0] = (word)ofl;
! 101: p[1] = 0;
! 102: p[2] = 0;
! 103: p[3] = 0;
! 104: p += 4;
! 105: for (; p < lim; p += 4) {
! 106: p[0] = (word)(p-4);
! 107: p[1] = 0;
! 108: p[2] = 0;
! 109: p[3] = 0;
! 110: };
! 111: return((ptr_t)(p-4));
! 112: }
! 113:
! 114: /* The same for size 2 uncleared objects */
! 115: ptr_t GC_build_fl2(h, ofl)
! 116: struct hblk *h;
! 117: ptr_t ofl;
! 118: {
! 119: register word * p = (word *)h;
! 120: register word * lim = (word *)(h + 1);
! 121:
! 122: p[0] = (word)ofl;
! 123: p[2] = (word)p;
! 124: p += 4;
! 125: for (; p < lim; p += 4) {
! 126: p[0] = (word)(p-2);
! 127: p[2] = (word)p;
! 128: };
! 129: return((ptr_t)(p-2));
! 130: }
! 131:
! 132: /* The same for size 4 uncleared objects */
! 133: ptr_t GC_build_fl4(h, ofl)
! 134: struct hblk *h;
! 135: ptr_t ofl;
! 136: {
! 137: register word * p = (word *)h;
! 138: register word * lim = (word *)(h + 1);
! 139:
! 140: p[0] = (word)ofl;
! 141: p[4] = (word)p;
! 142: p += 8;
! 143: for (; p < lim; p += 8) {
! 144: p[0] = (word)(p-4);
! 145: p[4] = (word)p;
! 146: };
! 147: return((ptr_t)(p-4));
! 148: }
! 149:
! 150: #endif /* !SMALL_CONFIG */
! 151:
! 152: /*
! 153: * Allocate a new heapblock for small objects of size n.
! 154: * Add all of the heapblock's objects to the free list for objects
! 155: * of that size.
! 156: * Set all mark bits if objects are uncollectable.
! 157: * Will fail to do anything if we are out of memory.
! 158: */
! 159: void GC_new_hblk(sz, kind)
! 160: register word sz;
! 161: int kind;
! 162: {
! 163: register word *p,
! 164: *prev;
! 165: word *last_object; /* points to last object in new hblk */
! 166: register struct hblk *h; /* the new heap block */
! 167: register GC_bool clear = GC_obj_kinds[kind].ok_init;
! 168:
! 169: # ifdef PRINTSTATS
! 170: if ((sizeof (struct hblk)) > HBLKSIZE) {
! 171: ABORT("HBLK SZ inconsistency");
! 172: }
! 173: # endif
! 174:
! 175: /* Allocate a new heap block */
! 176: h = GC_allochblk(sz, kind, 0);
! 177: if (h == 0) return;
! 178:
! 179: /* Mark all objects if appropriate. */
! 180: if (IS_UNCOLLECTABLE(kind)) GC_set_hdr_marks(HDR(h));
! 181:
! 182: /* Handle small objects sizes more efficiently. For larger objects */
! 183: /* the difference is less significant. */
! 184: # ifndef SMALL_CONFIG
! 185: switch (sz) {
! 186: case 1: GC_obj_kinds[kind].ok_freelist[1] =
! 187: GC_build_fl1(h, GC_obj_kinds[kind].ok_freelist[1]);
! 188: return;
! 189: case 2: if (clear) {
! 190: GC_obj_kinds[kind].ok_freelist[2] =
! 191: GC_build_fl_clear2(h, GC_obj_kinds[kind].ok_freelist[2]);
! 192: } else {
! 193: GC_obj_kinds[kind].ok_freelist[2] =
! 194: GC_build_fl2(h, GC_obj_kinds[kind].ok_freelist[2]);
! 195: }
! 196: return;
! 197: case 3: if (clear) {
! 198: GC_obj_kinds[kind].ok_freelist[3] =
! 199: GC_build_fl_clear3(h, GC_obj_kinds[kind].ok_freelist[3]);
! 200: return;
! 201: } else {
! 202: /* It's messy to do better than the default here. */
! 203: break;
! 204: }
! 205: case 4: if (clear) {
! 206: GC_obj_kinds[kind].ok_freelist[4] =
! 207: GC_build_fl_clear4(h, GC_obj_kinds[kind].ok_freelist[4]);
! 208: } else {
! 209: GC_obj_kinds[kind].ok_freelist[4] =
! 210: GC_build_fl4(h, GC_obj_kinds[kind].ok_freelist[4]);
! 211: }
! 212: return;
! 213: default:
! 214: break;
! 215: }
! 216: # endif /* !SMALL_CONFIG */
! 217:
! 218: /* Clear the page if necessary. */
! 219: if (clear) BZERO(h, HBLKSIZE);
! 220:
! 221: /* Add objects to free list */
! 222: p = &(h -> hb_body[sz]); /* second object in *h */
! 223: prev = &(h -> hb_body[0]); /* One object behind p */
! 224: last_object = (word *)((char *)h + HBLKSIZE);
! 225: last_object -= sz;
! 226: /* Last place for last object to start */
! 227:
! 228: /* make a list of all objects in *h with head as last object */
! 229: while (p <= last_object) {
! 230: /* current object's link points to last object */
! 231: obj_link(p) = (ptr_t)prev;
! 232: prev = p;
! 233: p += sz;
! 234: }
! 235: p -= sz; /* p now points to last object */
! 236:
! 237: /*
! 238: * put p (which is now head of list of objects in *h) as first
! 239: * pointer in the appropriate free list for this size.
! 240: */
! 241: obj_link(h -> hb_body) = GC_obj_kinds[kind].ok_freelist[sz];
! 242: GC_obj_kinds[kind].ok_freelist[sz] = ((ptr_t)p);
! 243: }
! 244:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to new_hblk.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gc