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/init-gc.c
ViewVC logotype

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

Parent Directory Parent Directory | Revision Log Revision Log


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

1 : monnier 2 /* init-gc.c
2 :     *
3 :     * COPYRIGHT (c) 1993 by AT&T Bell Laboratories.
4 :     *
5 :     * The GC initialization code.
6 :     *
7 :     */
8 :    
9 :     #ifdef PAUSE_STATS /* GC pause statistics are UNIX dependent */
10 :     # include "ml-unixdep.h"
11 :     #endif
12 :    
13 :     #include <stdarg.h>
14 :     #include "ml-base.h"
15 :     #include "ml-options.h"
16 :     #include "ml-limits.h"
17 :     #include "memory.h"
18 :     #include "ml-state.h"
19 :     #include "ml-values.h"
20 :     #include "ml-objects.h"
21 :     #include "cntr.h"
22 :     #include "heap.h"
23 :     #include "heap-monitor.h"
24 :     #include "ml-globals.h"
25 :     #include "ml-timer.h"
26 :     #include "gc-stats.h"
27 :     #include "ml-mp.h"
28 :    
29 :     PVT int DfltRatios[MAX_NUM_GENS] = {
30 :     DFLT_RATIO1, DFLT_RATIO2, DFLT_RATIO, DFLT_RATIO,
31 :     DFLT_RATIO, DFLT_RATIO, DFLT_RATIO
32 :     };
33 :    
34 :     #ifdef TWO_LEVEL_MAP
35 :     # error two level map not supported
36 :     #else
37 :     aid_t *BIBOP;
38 :     #endif
39 :    
40 :     #ifdef COLLECT_STATS /** should this go into gc-stats.c ??? **/
41 :     bool_t StatsOn = TRUE; /* if TRUE, then generate stats */
42 :     int StatsFD = -1; /* the file descriptor to write the data to */
43 :     stat_rec_t StatsBuf[STATS_BUF_SZ]; /* buffer of data */
44 :     int NStatsRecs; /* the number of records in the buffer */
45 :     #endif
46 :    
47 :    
48 :     /* ParseHeapParams:
49 :     *
50 :     * Parse and heap parameters from the command-line arguments.
51 :     */
52 :     heap_params_t *ParseHeapParams (char **argv)
53 :     {
54 :     char option[MAX_OPT_LEN], *optionArg, **nextArg;
55 :     bool_t errFlg = FALSE;
56 :     char *arg;
57 :     heap_params_t *params;
58 :    
59 :     if ((params = NEW_OBJ(heap_params_t)) == NIL(heap_params_t *)) {
60 :     Die("unable to allocate heap_params");
61 :     }
62 :    
63 :     /* We use 0 or "-1" to signify that the default value should be used. */
64 :     params->allocSz = 0;
65 :     params->numGens = -1;
66 :     params->cacheGen = -1;
67 :    
68 :     #define MATCH(opt) (strcmp(opt, option) == 0)
69 :     #define CHECK(opt) { \
70 :     if (optionArg[0] == '\0') { \
71 :     errFlg = TRUE; \
72 :     Error("missing argument for \"%s\" option\n", opt); \
73 :     continue; \
74 :     } \
75 :     } /* CHECK */
76 :    
77 :     while ((arg = *argv++) != NIL(char *)) {
78 :     if (isRuntimeOption(arg, option, &optionArg)) {
79 :     if (MATCH("alloc")) { /* set allocation size */
80 :     CHECK("alloc");
81 :     if ((params->allocSz = GetSzOption(ONE_K, optionArg)) < 0) {
82 :     errFlg = TRUE;
83 :     Error ("bad argument for \"@SMLalloc\" option\n");
84 :     }
85 :     }
86 :     else if (MATCH("ngens")) {
87 :     CHECK("ngens");
88 :     params->numGens = atoi(optionArg);
89 :     if (params->numGens < 1)
90 :     params->numGens = 1;
91 :     else if (params->numGens > MAX_NGENS)
92 :     params->numGens = MAX_NGENS;
93 :     }
94 :     else if (MATCH("vmcache")) {
95 :     CHECK("vmcache");
96 :     params->cacheGen = atoi(optionArg);
97 :     if (params->cacheGen < 0)
98 :     params->cacheGen = 0;
99 :     else if (params->cacheGen > MAX_NGENS)
100 :     params->cacheGen = MAX_NGENS;
101 :     }
102 :     }
103 :     if (errFlg)
104 :     return NIL(heap_params_t *);
105 :     } /* while */
106 :    
107 :     return params;
108 :    
109 :     } /* end of ParseHeapParams */
110 :    
111 :     /* InitHeap:
112 :     *
113 :     * Create and initialize the heap.
114 :     */
115 :     void InitHeap (ml_state_t *msp, bool_t isBoot, heap_params_t *params)
116 :     {
117 :     int i, j, ratio, max_sz;
118 :     heap_t *heap;
119 :     gen_t *gen;
120 :     mem_obj_t *baseObj;
121 :     ml_val_t *allocBase;
122 :    
123 :     if (params->allocSz == 0) params->allocSz = DFLT_ALLOC;
124 :     if (params->numGens < 0) params->numGens = DFLT_NGENS;
125 :     if (params->cacheGen < 0) params->cacheGen = DFLT_CACHE_GEN;
126 :    
127 :     /* First we initialize the underlying memory system */
128 :     MEM_InitMemory ();
129 :    
130 :     /* allocate the base memory object (holds the BIBOP and allocation space) */
131 :     {
132 :     long bibopSz;
133 :    
134 :     #ifdef TWO_LEVEL_MAP
135 :     # error two level map not supported
136 :     #else
137 :     bibopSz = BIBOP_SZ * sizeof(aid_t);
138 :     #endif
139 :     baseObj = MEM_AllocMemObj (MAX_NUM_PROCS*params->allocSz + bibopSz);
140 :     if (baseObj == NIL(mem_obj_t *))
141 :     Die ("unable to allocate memory object for BIBOP");
142 :     BIBOP = (bibop_t)MEMOBJ_BASE(baseObj);
143 :     allocBase = (ml_val_t *)(((Addr_t)BIBOP) + bibopSz);
144 :     }
145 :    
146 :     /* initialize the BIBOP */
147 :     #ifdef TWO_LEVEL_MAP
148 :     # error two level map not supported
149 :     #else
150 :     for (i = 0; i < BIBOP_SZ; i++)
151 :     BIBOP[i] = AID_UNMAPPED;
152 :     #endif
153 :    
154 :     /* initialize heap descriptor */
155 :     heap = NEW_OBJ(heap_t);
156 :     memset ((char *)heap, 0, sizeof(heap_t));
157 :     for (i = 0; i < MAX_NUM_GENS; i++) {
158 :     ratio = DfltRatios[i];
159 :     if (i == 0)
160 :     max_sz = MAX_SZ1(params->allocSz * MAX_NUM_PROCS);
161 :     else
162 :     /** NOTE: the following is bogus **/
163 :     max_sz = (ratio * heap->gen[i-1]->arena[0]->maxSizeB) / 2;
164 :     gen =
165 :     heap->gen[i] = NEW_OBJ(gen_t);
166 :     gen->heap = heap;
167 :     gen->genNum = i+1;
168 :     gen->numGCs = 0;
169 :     gen->lastPrevGC = 0;
170 :     gen->ratio = ratio;
171 :     gen->toObj = NIL(mem_obj_t *);
172 :     gen->fromObj = NIL(mem_obj_t *);
173 :     gen->cacheObj = NIL(mem_obj_t *);
174 :     gen->dirty = NIL(card_map_t *);
175 :     for (j = 0; j < NUM_ARENAS; j++) {
176 :     gen->arena[j] = NEW_OBJ(arena_t);
177 :     gen->arena[j]->tospSizeB = 0;
178 :     gen->arena[j]->reqSizeB = 0;
179 :     gen->arena[j]->maxSizeB = max_sz;
180 :     gen->arena[j]->id = MAKE_AID(i+1, j+1, 0);
181 :     }
182 :     for (j = 0; j < NUM_BIGOBJ_KINDS; j++)
183 :     gen->bigObjs[j] = NIL(bigobj_desc_t *);
184 :     }
185 :     for (i = 0; i < params->numGens; i++) {
186 :     int k = (i == params->numGens-1) ? i : i+1;
187 :     for (j = 0; j < NUM_ARENAS; j++)
188 :     heap->gen[i]->arena[j]->nextGen = heap->gen[k]->arena[j];
189 :     }
190 :     heap->numGens = params->numGens;
191 :     heap->cacheGen = params->cacheGen;
192 :     heap->numMinorGCs = 0;
193 :     heap->numBORegions = 0;
194 :     heap->bigRegions = NIL(bigobj_region_t *);
195 :     heap->freeBigObjs = NEW_OBJ(bigobj_desc_t);
196 :     heap->freeBigObjs->obj = (Addr_t)0;
197 :     heap->freeBigObjs->sizeB = 0;
198 :     heap->freeBigObjs->state = BO_FREE;
199 :     heap->freeBigObjs->prev = heap->freeBigObjs;
200 :     heap->freeBigObjs->next = heap->freeBigObjs;
201 :     heap->weakList = NIL(ml_val_t *);
202 :    
203 :     /* initialize new space */
204 :     heap->baseObj = baseObj;
205 :     heap->allocBase = allocBase;
206 :     heap->allocSzB = MAX_NUM_PROCS*params->allocSz;
207 :     MarkRegion (BIBOP, (ml_val_t *)BIBOP, MEMOBJ_SZB(heap->baseObj), AID_NEW);
208 :     #ifdef VERBOSE
209 :     SayDebug ("NewSpace = [%#x, %#x:%#x), %d bytes\n",
210 :     heap->allocBase, HEAP_LIMIT(heap),
211 :     (Word_t)(heap->allocBase)+params->allocSz, params->allocSz);
212 :     #endif
213 :    
214 :     #ifdef GC_STATS
215 :     ClearGCStats (heap);
216 :     #endif
217 :     #if defined(COLLECT_STATS)
218 :     if (StatsFD > 0) {
219 :     stat_hdr_t hdr;
220 :     CNTR_ZERO(&(heap->numAlloc));
221 :     hdr.mask = STATMASK_ALLOC|STATMASK_NGENS|STATMASK_START|STATMASK_STOP;
222 :     hdr.isNewRuntime = 1;
223 :     hdr.allocSzB = params->allocSz;
224 :     hdr.numGens = params->numGens;
225 :     gettimeofday (&(hdr.startTime), NIL(struct timezone *));
226 :     write (StatsFD, (char *)&hdr, sizeof(stat_hdr_t));
227 :     }
228 :     #endif
229 :    
230 :     if (isBoot) {
231 :     /* Create the first generation's to-space. */
232 :     for (i = 0; i < NUM_ARENAS; i++)
233 :     heap->gen[0]->arena[i]->tospSizeB = RND_MEMOBJ_SZB(2 * heap->allocSzB);
234 :     if (NewGeneration(heap->gen[0]) == FAILURE)
235 :     Die ("unable to allocate initial first generation space\n");
236 :     for (i = 0; i < NUM_ARENAS; i++)
237 :     heap->gen[0]->arena[i]->oldTop = heap->gen[0]->arena[i]->tospBase;
238 :     }
239 :    
240 :     /* initialize the GC related parts of the ML state */
241 :     msp->ml_heap = heap;
242 :     msp->ml_allocPtr = (ml_val_t *)(msp->ml_allocArena);
243 :     #ifdef SOFT_POLL
244 :     ResetPollLimit (msp);
245 :     #else
246 :     msp->ml_limitPtr = HEAP_LIMIT(heap);
247 :     #endif
248 :    
249 :     } /* end of InitHeap */
250 :    
251 :    
252 :     #ifdef GC_STATS
253 :     /* ClearGCStats:
254 :     */
255 :     void ClearGCStats (heap_t *heap)
256 :     {
257 :     int i, j;
258 :    
259 :     CNTR_ZERO(&(heap->numAlloc));
260 :     for (i = 0; i < MAX_NUM_GENS; i++) {
261 :     for (j = 0; j < NUM_ARENAS; j++) {
262 :     CNTR_ZERO(&(heap->numCopied[i][j]));
263 :     }
264 :     }
265 :    
266 :     } /* end of ClearStats */
267 :     #endif
268 :    

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