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-in.c
ViewVC logotype

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

Parent Directory Parent Directory | Revision Log Revision Log


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

1 : monnier 2 /* blast-in.c
2 :     *
3 :     * COPYRIGHT (c) 1993 by AT&T Bell Laboratories.
4 :     */
5 :    
6 :     #include <stdio.h>
7 :     #include "ml-base.h"
8 :     #include "ml-values.h"
9 :     #include "ml-state.h"
10 :     #include "heap.h"
11 :     #include "ml-heap-image.h"
12 :     #include "c-globals-tbl.h"
13 :     #include "heap-input.h"
14 :    
15 :    
16 :     /* local routines */
17 :     PVT status_t ReadImage (ml_state_t *msp, inbuf_t *bp, ml_val_t *objRef);
18 :    
19 :    
20 :     /* BlastIn:
21 :     *
22 :     * Build an ML heap object from a sequence of bytes; the fd is the underlying
23 :     * file descriptor (== -1, if blasting from a string), buf is any pre-read
24 :     * bytes of data, and nbytesP points to the number of bytes in buf.
25 :     */
26 :     ml_val_t BlastIn (ml_state_t *msp, Byte_t *buf, long len, bool_t *errFlg)
27 :     {
28 :     inbuf_t inBuf;
29 :     ml_image_hdr_t hdr;
30 :     ml_val_t obj;
31 :    
32 :     inBuf.needsSwap = FALSE;
33 :     inBuf.file = NULL;
34 :     inBuf.base = buf;
35 :     inBuf.buf = buf;
36 :     inBuf.nbytes = len;
37 :    
38 :     /* read the object header */
39 :     if (HeapIO_ReadBlock (&inBuf, &hdr, sizeof(hdr)) == FAILURE) {
40 :     *errFlg = TRUE;
41 :     return ML_unit;
42 :     }
43 :     if (hdr.byteOrder != ORDER) {
44 :     if (BIGENDIAN_TO_HOST(hdr.byteOrder) != ORDER) {
45 :     *errFlg = TRUE;
46 :     return ML_unit;
47 :     }
48 :     hdr.magic = BIGENDIAN_TO_HOST(hdr.magic);
49 :     hdr.kind = BIGENDIAN_TO_HOST(hdr.kind);
50 :     inBuf.needsSwap = TRUE;
51 :     }
52 :     if (hdr.magic != BLAST_MAGIC) {
53 :     *errFlg = TRUE;
54 :     return ML_unit;
55 :     }
56 :    
57 :     switch (hdr.kind) {
58 :     case BLAST_IMAGE:
59 :     if (ReadImage(msp, &inBuf, &obj) == FAILURE) {
60 :     *errFlg = TRUE;
61 :     return ML_unit;
62 :     }
63 :     break;
64 :     case BLAST_UNBOXED: {
65 :     ml_blast_hdr_t bhdr;
66 :     if (HeapIO_ReadBlock(&inBuf, &bhdr, sizeof(bhdr)) == FAILURE) {
67 :     *errFlg = TRUE;
68 :     return ML_unit;
69 :     }
70 :     else
71 :     obj = bhdr.rootObj;
72 :     } break;
73 :     default:
74 :     *errFlg = TRUE;
75 :     return ML_unit;
76 :     }
77 :    
78 :     return obj;
79 :    
80 :     } /* end of BlastIn */
81 :    
82 :    
83 :     /* ReadImage:
84 :     */
85 :     PVT status_t ReadImage (ml_state_t *msp, inbuf_t *bp, ml_val_t *objRef)
86 :     {
87 :     ml_blast_hdr_t blastHdr;
88 :     ml_val_t *externs;
89 :     heap_arena_hdr_t *arenaHdrs[NUM_OBJ_KINDS], *arenaHdrsBuf;
90 :     int arenaHdrsSize, i;
91 :     gen_t *gen1 = msp->ml_heap->gen[0];
92 :    
93 :     if ((HeapIO_ReadBlock(bp, &blastHdr, sizeof(blastHdr)) == FAILURE)
94 :     || (blastHdr.numArenas > NUM_ARENAS)
95 :     || (blastHdr.numBOKinds > NUM_BIGOBJ_KINDS))
96 :     return FAILURE;
97 :    
98 :     /* read the externals table */
99 :     externs = HeapIO_ReadExterns (bp);
100 :    
101 :     /* read the arena headers. */
102 :     arenaHdrsSize = (blastHdr.numArenas + blastHdr.numBOKinds)
103 :     * sizeof(heap_arena_hdr_t);
104 :     arenaHdrsBuf = (heap_arena_hdr_t *) MALLOC (arenaHdrsSize);
105 :     if (HeapIO_ReadBlock (bp, arenaHdrsBuf, arenaHdrsSize) == FAILURE) {
106 :     FREE (arenaHdrsBuf);
107 :     return FAILURE;
108 :     }
109 :     for (i = 0; i < NUM_OBJ_KINDS; i++)
110 :     arenaHdrs[i] = NIL(heap_arena_hdr_t *);
111 :     for (i = 0; i < blastHdr.numArenas; i++) {
112 :     heap_arena_hdr_t *p = &(arenaHdrsBuf[i]);
113 :     arenaHdrs[p->objKind] = p;
114 :     }
115 :     /** DO BIG OBJECT HEADERS TOO **/
116 :    
117 :     /* check the heap to see if there is enough free space in the 1st generation */
118 :     {
119 :     Addr_t allocSzB = msp->ml_heap->allocSzB;
120 :     bool_t needsGC = FALSE;
121 :    
122 :     for (i = 0; i < NUM_ARENAS; i++) {
123 :     arena_t *ap = gen1->arena[i];
124 :     if ((arenaHdrs[i] != NIL(heap_arena_hdr_t *)) && ((! isACTIVE(ap))
125 :     || (AVAIL_SPACE(ap) < arenaHdrs[i]->info.o.sizeB + allocSzB))) {
126 :     needsGC = TRUE;
127 :     ap->reqSizeB = arenaHdrs[i]->info.o.sizeB;
128 :     }
129 :     }
130 :     if (needsGC) {
131 :     if (bp->nbytes > 0) {
132 :     /* the GC may cause the buffer to move */
133 :     ml_val_t buffer = PTR_CtoML(bp->base);
134 :     InvokeGCWithRoots (msp, 1, &buffer, NIL(ml_val_t *));
135 :     if (buffer != PTR_CtoML(bp->base)) {
136 :     /* the buffer moved, so adjust the buffer pointers */
137 :     Byte_t *newBase = PTR_MLtoC(Byte_t, buffer);
138 :     bp->buf = newBase + (bp->buf - bp->base);
139 :     bp->base = newBase;
140 :     }
141 :     }
142 :     else
143 :     InvokeGC (msp, 1);
144 :     }
145 :     }
146 :    
147 :     /** Read the blasted objects **/
148 :     {
149 :     Addr_t arenaBase[NUM_ARENAS];
150 :    
151 :     for (i = 0; i < NUM_ARENAS; i++) {
152 :     if (arenaHdrs[i] != NIL(heap_arena_hdr_t *)) {
153 :     arena_t *ap = gen1->arena[i];
154 :     arenaBase[i] = (Addr_t)(ap->nextw);
155 :     HeapIO_ReadBlock (bp, (ap->nextw), arenaHdrs[i]->info.o.sizeB);
156 :     /*SayDebug ("[%2d] Read [%#x..%#x)\n", i+1, ap->nextw,*/
157 :     /*(Addr_t)(ap->nextw)+arenaHdrs[i]->info.o.sizeB);*/
158 :     }
159 :     }
160 :    
161 :     /* adjust the pointers */
162 :     for (i = 0; i < NUM_ARENAS; i++) {
163 :     if (arenaHdrs[i] != NIL(heap_arena_hdr_t *)) {
164 :     arena_t *ap = gen1->arena[i];
165 :     if (i != STRING_INDX) {
166 :     ml_val_t *p, *stop;
167 :     p = ap->nextw;
168 :     stop = (ml_val_t *)((Addr_t)p + arenaHdrs[i]->info.o.sizeB);
169 :     while (p < stop) {
170 :     ml_val_t w = *p;
171 :     if (! isUNBOXED(w)) {
172 :     if (isEXTERNTAG(w)) {
173 :     w = externs[EXTERNID(w)];
174 :     }
175 :     else if (! isDESC(w)) {
176 :     /*SayDebug ("adjust (@%#x) %#x --> ", p, w);*/
177 :     w = PTR_CtoML(arenaBase[HIO_GET_ID(w)] + HIO_GET_OFFSET(w));
178 :     /*SayDebug ("%#x\n", w);*/
179 :     }
180 :     *p = w;
181 :     }
182 :     p++;
183 :     }
184 :     ap->nextw =
185 :     ap->sweep_nextw = stop;
186 :     }
187 :     else
188 :     ap->nextw = (ml_val_t *)((Addr_t)(ap->nextw)
189 :     + arenaHdrs[i]->info.o.sizeB);
190 :     }
191 :     } /* end of for */
192 :    
193 :     /* adjust the root object pointer */
194 :     if (isEXTERNTAG(blastHdr.rootObj))
195 :     *objRef = externs[EXTERNID(blastHdr.rootObj)];
196 :     else
197 :     *objRef = PTR_CtoML(
198 :     arenaBase[HIO_GET_ID(blastHdr.rootObj)]
199 :     + HIO_GET_OFFSET(blastHdr.rootObj));
200 :     /*SayDebug ("root = %#x, adjusted = %#x\n", blastHdr.rootObj, *objRef);*/
201 :     }
202 :    
203 :     FREE (arenaHdrsBuf);
204 :     FREE (externs);
205 :    
206 :     return SUCCESS;
207 :    
208 :     } /* end of ReadImage */

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