Home My Page Projects Code Snippets Project Openings SML/NJ
Summary Activity Forums Tracker Lists Tasks Docs Surveys News SCM Files

SCM Repository

[smlnj] Annotation of /sml/trunk/src/runtime/gc/gc-util.c
ViewVC logotype

Annotation of /sml/trunk/src/runtime/gc/gc-util.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 223 - (view) (download) (as text)
Original Path: sml/branches/SMLNJ/src/runtime/gc/gc-util.c

1 : monnier 2 /* gc-util.c
2 :     *
3 :     * COPYRIGHT (c) 1993 by AT&T Bell Laboratories.
4 :     *
5 :     * Garbage collection utility routines.
6 :     *
7 :     */
8 :    
9 :     #include <stdarg.h>
10 :     #include "ml-base.h"
11 :     #include "ml-limits.h"
12 :     #include "ml-values.h"
13 :     #include "memory.h"
14 :     #include "card-map.h"
15 :     #include "heap.h"
16 :     #include "heap-monitor.h"
17 :    
18 :    
19 :     /* NewGeneration:
20 :     *
21 :     * Allocate and partition the space for a generation.
22 :     */
23 :     status_t NewGeneration (gen_t *gen)
24 :     {
25 :     int i;
26 :     Addr_t tot_sz;
27 :     ml_val_t *p;
28 :     mem_obj_t *memobj;
29 :     arena_t *ap;
30 :    
31 :     /* Compute the total size */
32 :     for (tot_sz = 0, i = 0; i < NUM_ARENAS; i++) {
33 :     if (isACTIVE(gen->arena[i]))
34 :     tot_sz += gen->arena[i]->tospSizeB;
35 :     }
36 :    
37 :     if ((gen->cacheObj != NIL(mem_obj_t *)) && (MEMOBJ_SZB(gen->cacheObj) >= tot_sz)) {
38 :     memobj = gen->cacheObj;
39 :     gen->cacheObj = NIL(mem_obj_t *);
40 :     }
41 :     else if ((memobj = MEM_AllocMemObj(tot_sz)) == NIL(mem_obj_t *)) {
42 :     /** Eventually we should try to allocate the generation as separate
43 :     ** chunks instead of failing.
44 :     **/
45 :     return FAILURE;
46 :     }
47 :    
48 :     /* Initialize the chunks */
49 :     gen->toObj = memobj;
50 :     #ifdef VERBOSE
51 :     SayDebug ("NewGeneration[%d]: tot_sz = %d, [%#x, %#x)\n",
52 :     gen->genNum, tot_sz, MEMOBJ_BASE(memobj), MEMOBJ_BASE(memobj) + MEMOBJ_SZB(memobj));
53 :     #endif
54 :     for (p = (ml_val_t *)MEMOBJ_BASE(memobj), i = 0; i < NUM_ARENAS; i++) {
55 :     ap = gen->arena[i];
56 :     if (isACTIVE(ap)) {
57 :     ap->tospBase = p;
58 :     ap->nextw = p;
59 :     ap->sweep_nextw = p;
60 :     p = (ml_val_t *)((Addr_t)p + ap->tospSizeB);
61 :     ap->tospTop = p;
62 :     MarkRegion (BIBOP, ap->tospBase, ap->tospSizeB, ap->id);
63 :     HeapMon_MarkRegion (gen->heap, ap->tospBase, ap->tospSizeB, ap->id);
64 :     #ifdef VERBOSE
65 :     SayDebug (" %#x: [%#x, %#x)\n", ap->id, ap->nextw, p);
66 :     #endif
67 :     }
68 :     else {
69 :     ap->tospBase = NIL(ml_val_t *);
70 :     ap->nextw = NIL(ml_val_t *);
71 :     ap->sweep_nextw = NIL(ml_val_t *);
72 :     ap->tospTop = NIL(ml_val_t *);
73 :     }
74 :     }
75 :    
76 :     ap = gen->arena[PAIR_INDX];
77 :     if (isACTIVE(ap)) {
78 :     /* The first slot of pair-space cannot be used, so that poly-equal won't fault */
79 :     *(ap->nextw++) = ML_unit;
80 :     *(ap->nextw++) = ML_unit;
81 :     ap->tospBase = ap->nextw;
82 :     ap->tospSizeB -= (2*WORD_SZB);
83 :     ap->sweep_nextw = ap->nextw;
84 :     }
85 :    
86 :     return SUCCESS;
87 :    
88 :     } /* end of NewGeneration */
89 :    
90 :    
91 :     /* FreeGeneration:
92 :     */
93 :     void FreeGeneration (heap_t *heap, int g)
94 :     {
95 :     gen_t *gen = heap->gen[g];
96 :     int i;
97 :    
98 :     if (gen->fromObj == NIL(mem_obj_t *))
99 :     return;
100 :    
101 :     #ifdef VERBOSE
102 :     SayDebug ("FreeGeneration [%d]: [%#x, %#x)\n", g+1, MEMOBJ_BASE(gen->fromObj),
103 :     MEMOBJ_BASE(gen->fromObj) + MEMOBJ_SZB(gen->fromObj));
104 :     #endif
105 :     if (g < heap->cacheGen) {
106 :     if (gen->cacheObj != NIL(mem_obj_t *)) {
107 :     if (MEMOBJ_SZB(gen->cacheObj) > MEMOBJ_SZB(gen->fromObj))
108 :     MEM_FreeMemObj (gen->fromObj);
109 :     else {
110 :     MEM_FreeMemObj (gen->cacheObj);
111 :     gen->cacheObj = gen->fromObj;
112 :     }
113 :     }
114 :     else
115 :     gen->cacheObj = gen->fromObj;
116 :     }
117 :     else
118 :     MEM_FreeMemObj (gen->fromObj);
119 :    
120 :     /** NOTE: since the arenas are contiguous, we could do this in one call **/
121 :     gen->fromObj = NIL(mem_obj_t *);
122 :     for (i = 0; i < NUM_ARENAS; i++) {
123 :     arena_t *ap = gen->arena[i];
124 :     if (ap->frspBase != NIL(ml_val_t *)) {
125 :     MarkRegion (BIBOP, ap->frspBase, ap->frspSizeB, AID_UNMAPPED);
126 :     HeapMon_MarkRegion (heap, ap->frspBase, ap->frspSizeB, AID_UNMAPPED);
127 :     ap->frspBase = NIL(ml_val_t *);
128 :     ap->frspSizeB = 0;
129 :     ap->frspTop = NIL(ml_val_t *);
130 :     }
131 :     }
132 :    
133 :     } /* end of FreeGeneration */
134 :    
135 :    
136 :     /* NewDirtyVector:
137 :     * Bind in a new dirty vector for the given generation, reclaiming the old
138 :     * vector.
139 :     */
140 :     void NewDirtyVector (gen_t *gen)
141 :     {
142 :     arena_t *ap = gen->arena[ARRAY_INDX];
143 :     int vecSz = (ap->tospSizeB / CARD_SZB);
144 :     int allocSzB = CARD_MAP_SZ(vecSz);
145 :    
146 :     if (gen->dirty == NIL(card_map_t *)) {
147 :     gen->dirty = (card_map_t *)MALLOC(allocSzB);
148 :     gen->dirty->mapSzB = allocSzB;
149 :     }
150 :     else if (allocSzB > gen->dirty->mapSzB) {
151 :     FREE(gen->dirty);
152 :     gen->dirty = (card_map_t *)MALLOC(allocSzB);
153 :     gen->dirty->mapSzB = allocSzB;
154 :     }
155 :     if (gen->dirty == NIL(card_map_t *)) {
156 :     Die ("unable to malloc dirty vector");
157 :     }
158 :     gen->dirty->baseAddr = ap->tospBase;
159 :     gen->dirty->numCards = vecSz;
160 :     #ifndef BIT_CARDS
161 :     memset (gen->dirty->map, CARD_CLEAN, allocSzB - (sizeof(card_map_t) - WORD_SZB));
162 :     #else
163 :     memset (gen->dirty->map, 0, allocSzB - (sizeof(card_map_t) - WORD_SZB));
164 :     #endif
165 :    
166 :     } /* end of NewDirtyVector. */
167 :    
168 :    
169 :     /* MarkRegion:
170 :     *
171 :     * Mark the BIBOP entries corresponding to the range [baseAddr, baseAddr+szB)
172 :     * with aid.
173 :     */
174 :     void MarkRegion (bibop_t bibop, ml_val_t *baseAddr, Word_t szB, aid_t aid)
175 :     {
176 :     #ifdef TWO_LEVEL_MAP
177 :     # error two level map not supported
178 :     #else
179 :     int start = BIBOP_ADDR_TO_INDEX(baseAddr);
180 :     int end = BIBOP_ADDR_TO_INDEX(((Addr_t)baseAddr)+szB);
181 :     #ifdef VERBOSE
182 :     /*SayDebug("MarkRegion [%#x..%#x) as %#x\n", baseAddr, ((Addr_t)baseAddr)+szB, aid); */
183 :     #endif
184 :    
185 :     while (start < end) {
186 :     bibop[start++] = aid;
187 :     }
188 :     #endif
189 :    
190 :     } /* end of MarkRegion */
191 :    
192 :    
193 :     /* ScanWeakPtrs:
194 :     *
195 :     * Scan the list of weak pointers, nullifying those that refer to dead
196 :     * (i.e., from-space) objects.
197 :     */
198 :     void ScanWeakPtrs (heap_t *heap)
199 :     {
200 : monnier 223 ml_val_t *p, *q, *obj, desc, fwdObj;
201 : monnier 2
202 :     /* SayDebug ("ScanWeakPtrs:\n"); */
203 :     for (p = heap->weakList; p != NIL(ml_val_t *); p = q) {
204 :     q = PTR_MLtoC(ml_val_t, UNMARK_PTR(p[0]));
205 :     obj = (ml_val_t *)(Addr_t)UNMARK_PTR(p[1]);
206 :     /* SayDebug (" %#x --> %#x ", p+1, obj); */
207 :    
208 :     switch (EXTRACT_OBJC(ADDR_TO_PAGEID(BIBOP, obj))) {
209 :     case OBJC_new:
210 :     case OBJC_record:
211 :     case OBJC_string:
212 :     case OBJC_array:
213 : monnier 223 desc = obj[-1];
214 : monnier 2 if (desc == DESC_forwarded) {
215 :     p[0] = DESC_weak;
216 : monnier 223 p[1] = PTR_CtoML(FOLLOW_FWDOBJ(obj));
217 :     /* SayDebug ("forwarded to %#x\n", FOLLOW_FWDOBJ(obj)); */
218 : monnier 2 }
219 :     else {
220 :     p[0] = DESC_null_weak;
221 :     p[1] = ML_unit;
222 :     /* SayDebug ("nullified\n"); */
223 :     }
224 :     break;
225 :     case OBJC_pair:
226 : monnier 223 if (isDESC(desc = obj[0])) {
227 : monnier 2 p[0] = DESC_weak;
228 : monnier 223 p[1] = PTR_CtoML(FOLLOW_FWDPAIR(desc, obj));
229 :     /* SayDebug ("(pair) forwarded to %#x\n", FOLLOW_FWDPAIR(desc, obj)); */
230 : monnier 2 }
231 :     else {
232 :     p[0] = DESC_null_weak;
233 :     p[1] = ML_unit;
234 :     /* SayDebug ("(pair) nullified\n"); */
235 :     }
236 :     break;
237 :     case OBJC_bigobj:
238 :     Die ("weak big object");
239 :     break;
240 :     } /* end of switch */
241 :     }
242 :    
243 :     heap->weakList = NIL(ml_val_t *);
244 :    
245 :     } /* end of ScanWeakPtrs */
246 :    

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0