Annotation of OpenXM_contrib/gc/new_hblk.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: * 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