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

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

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