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 2 - (view) (download) (as text)

1 : monnier 2 /* 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 :     obj_info_t info;
34 :     ml_val_t blastedObj;
35 :    
36 :     /* Collect allocation space */
37 :     InvokeGCWithRoots (msp, 0, &obj, NIL(ml_val_t *));
38 :    
39 :     info = GetObjInfo (obj);
40 :    
41 :     if (info.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, info.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 :     return blastedObj;
94 :     }
95 :    
96 :     } /* end of BlastUnboxed */
97 :    
98 :    
99 :     /* BlastHeap:
100 :     *
101 :     * Blast out the heap image.
102 :     */
103 :     PVT ml_val_t BlastHeap (ml_state_t *msp, ml_val_t obj, blast_res_t *info)
104 :     {
105 :     int pagesize = GETPAGESIZE();
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 :     long offset;
116 :     int arenaHdrSz, i, j, numArenas;
117 :     ml_val_t blastedObj;
118 :     writer_t *wr;
119 :    
120 :     /* compute the arena offsets in the heap image */
121 :     for (i = 0; i < NUM_ARENAS; i++)
122 :     totArenaSzB[i] = 0;
123 :     /* the embedded literals go first */
124 :     totArenaSzB[STRING_INDX] = BlastGC_AssignLitAddrs (info, STRING_INDX, 0);
125 :     /* DEBUG SayDebug("%d bytes of string literals\n", totArenaSzB[STRING_INDX]); */
126 :     for (i = 0; i < maxGen; i++) {
127 :     for (j = 0; j < NUM_ARENAS; j++) {
128 :     arena_t *ap = heap->gen[i]->arena[j];
129 :     adjust[i][j].offset = totArenaSzB[j];
130 :     if (isACTIVE(ap)) {
131 :     /* DEBUG SayDebug("[%d][%d] base = %#x, nextw = %#x, %d bytes\n", */
132 :     /* DEBUG i, j, ap->tospBase, ap->nextw, (Addr_t)(ap->nextw) - (Addr_t)(ap->tospBase)); */
133 :     totArenaSzB[j] += (Addr_t)(ap->nextw) - (Addr_t)(ap->tospBase);
134 :     adjust[i][j].base = (Addr_t)(ap->tospBase);
135 :     }
136 :     else
137 :     adjust[i][j].base = 0;
138 :     }
139 :     }
140 :     /* DEBUG for (i = 0; i < NUM_ARENAS; i++) SayDebug ("arena %d: %d bytes\n", i+1, totArenaSzB[i]); */
141 :     /** WHAT ABOUT THE BIG OBJECTS??? **/
142 :    
143 :     /* Compute the total size of the blasted object */
144 :     for (i = 0, numArenas = 0, totSzB = 0; i < NUM_ARENAS; i++) {
145 :     if (totArenaSzB[i] > 0) {
146 :     numArenas++;
147 :     totSzB += totArenaSzB[i];
148 :     }
149 :     }
150 :     totSzB += (sizeof(ml_image_hdr_t) + sizeof(ml_blast_hdr_t)
151 :     + (numArenas * sizeof(heap_arena_hdr_t)));
152 :     /** COUNT SPACE FOR BIG OBJECTS **/
153 :    
154 :     /* include the space for the external symbols */
155 :     totSzB += sizeof(extern_tbl_hdr_t) + ExportTableSz(info->exportTbl);
156 :    
157 :     /* allocate the heap object for the blasted representation, and initialize
158 :     * the writer.
159 :     */
160 :     blastedObj = AllocBlastData (msp, totSzB);
161 :     wr = WR_OpenMem (PTR_MLtoC(Byte_t, blastedObj), totSzB);
162 :    
163 :     /* initialize the arena headers */
164 :     arenaHdrSz = numArenas * sizeof(heap_arena_hdr_t);
165 :     arenaHdrsBuf = (heap_arena_hdr_t *) MALLOC (arenaHdrSz);
166 :     for (p = arenaHdrsBuf, i = 0; i < NUM_ARENAS; i++) {
167 :     if (totArenaSzB[i] > 0) {
168 :     p->gen = 0;
169 :     p->objKind = i;
170 :     p->info.o.baseAddr = 0; /* not used */
171 :     p->info.o.sizeB = totArenaSzB[i];
172 :     p->info.o.roundedSzB = -1; /* not used */
173 :     p->offset = -1; /* not used */
174 :     arenaHdrs[i] = p;
175 :     p++;
176 :     }
177 :     else
178 :     arenaHdrs[i] = NIL(heap_arena_hdr_t *);
179 :     }
180 :     /** WHAT ABOUT BIG OBJECTS **/
181 :    
182 :     /* blast out the image header */
183 :     if (HeapIO_WriteImageHeader (wr, BLAST_IMAGE) == FAILURE) {
184 :     FREE (arenaHdrsBuf);
185 :     return BLAST_ERROR;
186 :     }
187 :    
188 :     /* blast out the blast header */
189 :     {
190 :     ml_blast_hdr_t hdr;
191 :    
192 :     hdr.numArenas = numArenas;
193 :     hdr.numBOKinds = 0; /** FIX THIS **/
194 :     hdr.numBORegions = 0; /** FIX THIS **/
195 :    
196 :     if (isEXTERNTAG(obj)) {
197 :     ASSERT(numArenas == 0);
198 :     hdr.rootObj = obj;
199 :     }
200 :     else {
201 :     aid_t aid = ADDR_TO_PAGEID(BIBOP, obj);
202 :    
203 :     if (IS_BIGOBJ_AID(aid)) {
204 :     embobj_info_t *p = FindEmbObj(info->embobjTbl, obj);
205 :    
206 :     if ((p == NIL(embobj_info_t *)) || (p->kind == USED_CODE)) {
207 :     Error ("blasting big objects not implemented\n");
208 :     FREE (arenaHdrsBuf);
209 :     return BLAST_ERROR;
210 :     }
211 :     else
212 :     hdr.rootObj = p->relAddr;
213 :     }
214 :     else {
215 :     Addr_t addr = PTR_MLtoADDR(obj);
216 :     int gen = EXTRACT_GEN(aid) - 1;
217 :     int kind = EXTRACT_OBJC(aid) - 1;
218 :     addr -= adjust[gen][kind].base;
219 :     addr += adjust[gen][kind].offset;
220 :     hdr.rootObj = HIO_TAG_PTR(kind, addr);
221 :     }
222 :     }
223 :    
224 :     WR_Write(wr, &hdr, sizeof(hdr));
225 :     if (WR_Error(wr)) {
226 :     FREE (arenaHdrsBuf);
227 :     return BLAST_ERROR;
228 :     }
229 :     }
230 :    
231 :     /* blast out the externals table */
232 :     if (HeapIO_WriteExterns(wr, info->exportTbl) == -1) {
233 :     FREE (arenaHdrsBuf);
234 :     return BLAST_ERROR;
235 :     }
236 :    
237 :     /* blast out the arena headers */
238 :     WR_Write (wr, arenaHdrsBuf, arenaHdrSz);
239 :     if (WR_Error(wr)) {
240 :     FREE (arenaHdrsBuf);
241 :     return BLAST_ERROR;
242 :     }
243 :    
244 :     /* blast out the heap itself */
245 :     for (i = 0; i < NUM_ARENAS; i++) {
246 :     if (i == STRING_INDX) {
247 :     /* blast out the embedded literals */
248 :     BlastGC_BlastLits (wr);
249 :     /* blast out the rest of the strings */
250 :     for (j = 0; j < maxGen; j++) {
251 :     arena_t *ap = heap->gen[j]->arena[i];
252 :     if (isACTIVE(ap)) {
253 :     WR_Write(wr, ap->tospBase,
254 :     (Addr_t)(ap->nextw)-(Addr_t)(ap->tospBase));
255 :     }
256 :     } /* end for */
257 :     }
258 :     else {
259 :     for (j = 0; j < maxGen; j++) {
260 :     arena_t *ap = heap->gen[j]->arena[i];
261 :     ml_val_t *p, *top;
262 :     if (isACTIVE(ap)) {
263 :     for (p = ap->tospBase, top = ap->nextw; p < top; p++) {
264 :     ml_val_t w = *p;
265 :     if (isBOXED(w)) {
266 :     aid_t aid = ADDR_TO_PAGEID(BIBOP, w);
267 :     if (isUNMAPPED(aid)) {
268 :     w = ExportCSymbol(info->exportTbl, w);
269 :     ASSERT (w != ML_unit);
270 :     }
271 :     else if (IS_BIGOBJ_AID(aid)) {
272 :     embobj_info_t *objInfo
273 :     = FindEmbObj(info->embobjTbl, w);
274 :    
275 :     if ((objInfo == NIL(embobj_info_t *))
276 :     || (objInfo->kind == USED_CODE))
277 :     Die("blast bigobj unimplemented");
278 :     else
279 :     w = objInfo->relAddr;
280 :     }
281 :     else {
282 :     /* adjust the pointer */
283 :     int gen = EXTRACT_GEN(aid)-1;
284 :     int kind = EXTRACT_OBJC(aid)-1;
285 :     Addr_t addr = PTR_MLtoADDR(w);
286 :     addr -= adjust[gen][kind].base;
287 :     addr += adjust[gen][kind].offset;
288 :     w = HIO_TAG_PTR(kind, addr);
289 :     }
290 :     }
291 :     WR_Put(wr, (Word_t)w);
292 :     }
293 :     }
294 :     } /* end for */
295 :     }
296 :     }
297 :    
298 :     FREE (arenaHdrsBuf);
299 :    
300 :     if (WR_Error(wr))
301 :     return BLAST_ERROR;
302 :     else
303 :     return blastedObj;
304 :    
305 :     } /* end of BlastHeap */
306 :    
307 :    
308 :     /* AllocBlastData:
309 :     *
310 :     * Allocate some heap memory for blasting an object.
311 :     */
312 :     PVT ml_val_t AllocBlastData (ml_state_t *msp, Addr_t sizeB)
313 :     {
314 :     heap_t *heap = msp->ml_heap;
315 :     ml_val_t desc = MAKE_DESC(sizeB, DTAG_string);
316 :     ml_val_t res;
317 :    
318 :     /** we probably should allocate space in the big-object region for these objects **/
319 :     if (sizeB < heap->allocSzB-(8*ONE_K)) {
320 :     ML_AllocWrite (msp, 0, desc);
321 :     res = ML_Alloc (msp, sizeB/WORD_SZB);
322 :     return res;
323 :     }
324 :     else {
325 :     Die ("blasting out of %d bytes not supported yet! Increase allocation arena size.", sizeB);
326 :     }
327 :    
328 :     } /* end of AllocBlastData */
329 :    

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