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/blast-out.c
ViewVC logotype

Annotation of /sml/trunk/src/runtime/gc/blast-out.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 651 - (view) (download) (as text)

1 : monnier 249 /* blast-out.c
2 :     *
3 :     * COPYRIGHT (c) 1993 by AT&T Bell Laboratories.
4 :     */
5 :    
6 :     #include "ml-osdep.h"
7 :     #include "ml-base.h"
8 :     #include "ml-values.h"
9 :     #include "ml-objects.h"
10 :     #include "ml-heap-image.h"
11 :     #include "c-globals-tbl.h"
12 :     #include "addr-hash.h"
13 :     #include "gc.h"
14 :     #include "blast-out.h"
15 :     #include "heap-output.h"
16 :     #include "heap-io.h"
17 :    
18 :     #define BLAST_ERROR ML_unit
19 :    
20 :     /* local routines */
21 :     PVT ml_val_t BlastUnboxed (ml_state_t *msp, ml_val_t obj);
22 :     PVT ml_val_t BlastHeap (ml_state_t *msp, ml_val_t obj, blast_res_t *info);
23 :     PVT ml_val_t AllocBlastData (ml_state_t *msp, Addr_t sizeB);
24 :    
25 :    
26 :     /* BlastOut:
27 :     *
28 :     * Linearize an ML object into a vector of bytes; return ML_unit on errors.
29 :     */
30 :     ml_val_t BlastOut (ml_state_t *msp, ml_val_t obj)
31 :     {
32 :     blast_res_t res;
33 :     int gen;
34 :     ml_val_t blastedObj;
35 :    
36 :     /* Collect allocation space */
37 :     InvokeGCWithRoots (msp, 0, &obj, NIL(ml_val_t *));
38 :    
39 :     gen = GetObjGen (obj);
40 :    
41 :     if (gen == -1) {
42 :     /* unboxed */
43 :     blastedObj = BlastUnboxed (msp, obj);
44 :     }
45 :     else { /* a regular ML object */
46 :     /* do the blast GC */
47 :     /* DEBUG CheckHeap (msp->ml_heap, msp->ml_heap->numGens); */
48 :     res = BlastGC (msp, &obj, gen);
49 :    
50 :     /* blast out the image */
51 :     blastedObj = BlastHeap (msp, obj, &res);
52 :    
53 :     /* repair the heap or finish the GC */
54 :     BlastGC_FinishUp (msp, &res);
55 :    
56 :     /* DEBUG CheckHeap (msp->ml_heap, res.maxGen); */
57 :     }
58 :    
59 :     return blastedObj;
60 :    
61 :     } /* end of BlastOut */
62 :    
63 :    
64 :     /* BlastUnboxed:
65 :     *
66 :     * Blast out an unboxed value.
67 :     */
68 :     PVT ml_val_t BlastUnboxed (ml_state_t *msp, ml_val_t obj)
69 :     {
70 :     ml_blast_hdr_t blastHdr;
71 :     int szB = sizeof(ml_image_hdr_t) + sizeof(ml_blast_hdr_t);
72 :     ml_val_t blastedObj;
73 :     writer_t *wr;
74 :    
75 :     /* allocate space for the object */
76 :     blastedObj = AllocBlastData (msp, szB);
77 :     wr = WR_OpenMem (PTR_MLtoC(Byte_t, blastedObj), szB);
78 :    
79 :     HeapIO_WriteImageHeader (wr, BLAST_UNBOXED);
80 :    
81 :     blastHdr.numArenas = 0;
82 :     blastHdr.numBOKinds = 0;
83 :     blastHdr.numBORegions = 0;
84 :     blastHdr.hasCode = FALSE;
85 :     blastHdr.rootObj = obj;
86 :    
87 :     WR_Write(wr, &blastHdr, sizeof(blastHdr));
88 :    
89 :     if (WR_Error(wr))
90 :     return ML_unit;
91 :     else {
92 :     WR_Free(wr);
93 :     SEQHDR_ALLOC (msp, blastedObj, DESC_string, blastedObj, szB);
94 :     return blastedObj;
95 :     }
96 :    
97 :     } /* end of BlastUnboxed */
98 :    
99 :    
100 :     /* BlastHeap:
101 :     *
102 :     * Blast out the heap image.
103 :     */
104 :     PVT ml_val_t BlastHeap (ml_state_t *msp, ml_val_t obj, blast_res_t *info)
105 :     {
106 :     heap_t *heap = msp->ml_heap;
107 :     int maxGen = info->maxGen;
108 :     Addr_t totArenaSzB[NUM_ARENAS], totSzB;
109 :     struct {
110 :     Addr_t base; /* the base address of the arena in the heap */
111 :     Addr_t offset; /* the relative position in the merged */
112 :     /* arena. */
113 :     } adjust[MAX_NUM_GENS][NUM_ARENAS];
114 :     heap_arena_hdr_t *p, *arenaHdrs[NUM_OBJ_KINDS], *arenaHdrsBuf;
115 :     int arenaHdrSz, i, j, numArenas;
116 :     ml_val_t blastedObj;
117 :     writer_t *wr;
118 :    
119 :     /* compute the arena offsets in the heap image */
120 :     for (i = 0; i < NUM_ARENAS; i++)
121 :     totArenaSzB[i] = 0;
122 :     /* the embedded literals go first */
123 :     totArenaSzB[STRING_INDX] = BlastGC_AssignLitAddrs (info, STRING_INDX, 0);
124 :     /* DEBUG SayDebug("%d bytes of string literals\n", totArenaSzB[STRING_INDX]); */
125 :     for (i = 0; i < maxGen; i++) {
126 :     for (j = 0; j < NUM_ARENAS; j++) {
127 :     arena_t *ap = heap->gen[i]->arena[j];
128 :     adjust[i][j].offset = totArenaSzB[j];
129 :     if (isACTIVE(ap)) {
130 :     /* DEBUG SayDebug("[%d][%d] base = %#x, nextw = %#x, %d bytes\n", */
131 :     /* DEBUG i, j, ap->tospBase, ap->nextw, (Addr_t)(ap->nextw) - (Addr_t)(ap->tospBase)); */
132 :     totArenaSzB[j] += (Addr_t)(ap->nextw) - (Addr_t)(ap->tospBase);
133 :     adjust[i][j].base = (Addr_t)(ap->tospBase);
134 :     }
135 :     else
136 :     adjust[i][j].base = 0;
137 :     }
138 :     }
139 :     /* DEBUG for (i = 0; i < NUM_ARENAS; i++) SayDebug ("arena %d: %d bytes\n", i+1, totArenaSzB[i]); */
140 :     /** WHAT ABOUT THE BIG OBJECTS??? **/
141 :    
142 :     /* Compute the total size of the blasted object */
143 :     for (i = 0, numArenas = 0, totSzB = 0; i < NUM_ARENAS; i++) {
144 :     if (totArenaSzB[i] > 0) {
145 :     numArenas++;
146 :     totSzB += totArenaSzB[i];
147 :     }
148 :     }
149 :     totSzB += (sizeof(ml_image_hdr_t) + sizeof(ml_blast_hdr_t)
150 :     + (numArenas * sizeof(heap_arena_hdr_t)));
151 :     /** COUNT SPACE FOR BIG OBJECTS **/
152 :    
153 :     /* include the space for the external symbols */
154 :     totSzB += sizeof(extern_tbl_hdr_t) + ExportTableSz(info->exportTbl);
155 :    
156 :     /* allocate the heap object for the blasted representation, and initialize
157 :     * the writer.
158 :     */
159 :     blastedObj = AllocBlastData (msp, totSzB);
160 :     wr = WR_OpenMem (PTR_MLtoC(Byte_t, blastedObj), totSzB);
161 :    
162 :     /* initialize the arena headers */
163 :     arenaHdrSz = numArenas * sizeof(heap_arena_hdr_t);
164 :     arenaHdrsBuf = (heap_arena_hdr_t *) MALLOC (arenaHdrSz);
165 :     for (p = arenaHdrsBuf, i = 0; i < NUM_ARENAS; i++) {
166 :     if (totArenaSzB[i] > 0) {
167 :     p->gen = 0;
168 :     p->objKind = i;
169 :     p->info.o.baseAddr = 0; /* not used */
170 :     p->info.o.sizeB = totArenaSzB[i];
171 :     p->info.o.roundedSzB = -1; /* not used */
172 :     p->offset = -1; /* not used */
173 :     arenaHdrs[i] = p;
174 :     p++;
175 :     }
176 :     else
177 :     arenaHdrs[i] = NIL(heap_arena_hdr_t *);
178 :     }
179 :     /** WHAT ABOUT BIG OBJECTS **/
180 :    
181 :     /* blast out the image header */
182 :     if (HeapIO_WriteImageHeader (wr, BLAST_IMAGE) == FAILURE) {
183 :     FREE (arenaHdrsBuf);
184 :     return BLAST_ERROR;
185 :     }
186 :    
187 :     /* blast out the blast header */
188 :     {
189 :     ml_blast_hdr_t hdr;
190 :    
191 :     hdr.numArenas = numArenas;
192 :     hdr.numBOKinds = 0; /** FIX THIS **/
193 :     hdr.numBORegions = 0; /** FIX THIS **/
194 :    
195 :     if (isEXTERNTAG(obj)) {
196 :     ASSERT(numArenas == 0);
197 :     hdr.rootObj = obj;
198 :     }
199 :     else {
200 :     aid_t aid = ADDR_TO_PAGEID(BIBOP, obj);
201 :    
202 :     if (IS_BIGOBJ_AID(aid)) {
203 :     embobj_info_t *p = FindEmbObj(info->embobjTbl, obj);
204 :    
205 :     if ((p == NIL(embobj_info_t *)) || (p->kind == USED_CODE)) {
206 :     Error ("blasting big objects not implemented\n");
207 :     FREE (arenaHdrsBuf);
208 :     return BLAST_ERROR;
209 :     }
210 :     else
211 :     hdr.rootObj = p->relAddr;
212 :     }
213 :     else {
214 :     Addr_t addr = PTR_MLtoADDR(obj);
215 :     int gen = EXTRACT_GEN(aid) - 1;
216 :     int kind = EXTRACT_OBJC(aid) - 1;
217 :     addr -= adjust[gen][kind].base;
218 :     addr += adjust[gen][kind].offset;
219 :     hdr.rootObj = HIO_TAG_PTR(kind, addr);
220 :     }
221 :     }
222 :    
223 :     WR_Write(wr, &hdr, sizeof(hdr));
224 :     if (WR_Error(wr)) {
225 :     FREE (arenaHdrsBuf);
226 :     return BLAST_ERROR;
227 :     }
228 :     }
229 :    
230 :     /* blast out the externals table */
231 :     if (HeapIO_WriteExterns(wr, info->exportTbl) == -1) {
232 :     FREE (arenaHdrsBuf);
233 :     return BLAST_ERROR;
234 :     }
235 :    
236 :     /* blast out the arena headers */
237 :     WR_Write (wr, arenaHdrsBuf, arenaHdrSz);
238 :     if (WR_Error(wr)) {
239 :     FREE (arenaHdrsBuf);
240 :     return BLAST_ERROR;
241 :     }
242 :    
243 :     /* blast out the heap itself */
244 :     for (i = 0; i < NUM_ARENAS; i++) {
245 :     if (i == STRING_INDX) {
246 :     /* blast out the embedded literals */
247 :     BlastGC_BlastLits (wr);
248 :     /* blast out the rest of the strings */
249 :     for (j = 0; j < maxGen; j++) {
250 :     arena_t *ap = heap->gen[j]->arena[i];
251 :     if (isACTIVE(ap)) {
252 :     WR_Write(wr, ap->tospBase,
253 :     (Addr_t)(ap->nextw)-(Addr_t)(ap->tospBase));
254 :     }
255 :     } /* end for */
256 :     }
257 :     else {
258 :     for (j = 0; j < maxGen; j++) {
259 :     arena_t *ap = heap->gen[j]->arena[i];
260 :     ml_val_t *p, *top;
261 :     if (isACTIVE(ap)) {
262 :     for (p = ap->tospBase, top = ap->nextw; p < top; p++) {
263 :     ml_val_t w = *p;
264 :     if (isBOXED(w)) {
265 :     aid_t aid = ADDR_TO_PAGEID(BIBOP, w);
266 :     if (isUNMAPPED(aid)) {
267 :     w = ExportCSymbol(info->exportTbl, w);
268 :     ASSERT (w != ML_unit);
269 :     }
270 :     else if (IS_BIGOBJ_AID(aid)) {
271 :     embobj_info_t *objInfo
272 :     = FindEmbObj(info->embobjTbl, w);
273 :    
274 :     if ((objInfo == NIL(embobj_info_t *))
275 :     || (objInfo->kind == USED_CODE))
276 :     Die("blast bigobj unimplemented");
277 :     else
278 :     w = objInfo->relAddr;
279 :     }
280 :     else {
281 :     /* adjust the pointer */
282 :     int gen = EXTRACT_GEN(aid)-1;
283 :     int kind = EXTRACT_OBJC(aid)-1;
284 :     Addr_t addr = PTR_MLtoADDR(w);
285 :     addr -= adjust[gen][kind].base;
286 :     addr += adjust[gen][kind].offset;
287 :     w = HIO_TAG_PTR(kind, addr);
288 :     }
289 :     }
290 :     WR_Put(wr, (Word_t)w);
291 :     }
292 :     }
293 :     } /* end for */
294 :     }
295 :     }
296 :    
297 :     FREE (arenaHdrsBuf);
298 :    
299 :     if (WR_Error(wr))
300 :     return BLAST_ERROR;
301 :     else {
302 :     SEQHDR_ALLOC (msp, blastedObj, DESC_string, blastedObj, totSzB);
303 :     return blastedObj;
304 :     }
305 :    
306 :     } /* end of BlastHeap */
307 :    
308 :    
309 :     /* AllocBlastData:
310 :     *
311 :     * Allocate some heap memory for blasting an object.
312 :     */
313 :     PVT ml_val_t AllocBlastData (ml_state_t *msp, Addr_t sizeB)
314 :     {
315 :     heap_t *heap = msp->ml_heap;
316 :     int nWords = BYTES_TO_WORDS(sizeB);
317 :     ml_val_t desc = MAKE_DESC(nWords, DTAG_raw32);
318 :     ml_val_t res;
319 :    
320 :     /** we probably should allocate space in the big-object region for these objects **/
321 :     if (sizeB < heap->allocSzB-(8*ONE_K)) {
322 :     ML_AllocWrite (msp, 0, desc);
323 :     res = ML_Alloc (msp, nWords);
324 :     return res;
325 :     }
326 :     else {
327 :     Die ("blasting out of %d bytes not supported yet! Increase allocation arena size.", sizeB);
328 :     }
329 :    
330 :     } /* end of AllocBlastData */
331 :    

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