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 1787 - (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 :     #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 : blume 569 char option[MAX_OPT_LEN], *optionArg;
55 : monnier 249 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 : jhr 1787 else if (MATCH("unlimited-heap"))
103 :     UnlimitedHeap = TRUE;
104 : monnier 249 }
105 :     if (errFlg)
106 :     return NIL(heap_params_t *);
107 :     } /* while */
108 :    
109 :     return params;
110 :    
111 :     } /* end of ParseHeapParams */
112 :    
113 :     /* InitHeap:
114 :     *
115 :     * Create and initialize the heap.
116 :     */
117 :     void InitHeap (ml_state_t *msp, bool_t isBoot, heap_params_t *params)
118 :     {
119 :     int i, j, ratio, max_sz;
120 :     heap_t *heap;
121 :     gen_t *gen;
122 :     mem_obj_t *baseObj;
123 :     ml_val_t *allocBase;
124 :    
125 :     if (params->allocSz == 0) params->allocSz = DFLT_ALLOC;
126 :     if (params->numGens < 0) params->numGens = DFLT_NGENS;
127 :     if (params->cacheGen < 0) params->cacheGen = DFLT_CACHE_GEN;
128 :    
129 :     /* First we initialize the underlying memory system */
130 :     MEM_InitMemory ();
131 :    
132 :     /* allocate the base memory object (holds the BIBOP and allocation space) */
133 :     {
134 :     long bibopSz;
135 :    
136 :     #ifdef TWO_LEVEL_MAP
137 :     # error two level map not supported
138 :     #else
139 :     bibopSz = BIBOP_SZ * sizeof(aid_t);
140 :     #endif
141 :     baseObj = MEM_AllocMemObj (MAX_NUM_PROCS*params->allocSz + bibopSz);
142 :     if (baseObj == NIL(mem_obj_t *))
143 :     Die ("unable to allocate memory object for BIBOP");
144 :     BIBOP = (bibop_t)MEMOBJ_BASE(baseObj);
145 :     allocBase = (ml_val_t *)(((Addr_t)BIBOP) + bibopSz);
146 :     }
147 :    
148 :     /* initialize the BIBOP */
149 :     #ifdef TWO_LEVEL_MAP
150 :     # error two level map not supported
151 :     #else
152 :     for (i = 0; i < BIBOP_SZ; i++)
153 :     BIBOP[i] = AID_UNMAPPED;
154 :     #endif
155 :    
156 :     /* initialize heap descriptor */
157 :     heap = NEW_OBJ(heap_t);
158 :     memset ((char *)heap, 0, sizeof(heap_t));
159 :     for (i = 0; i < MAX_NUM_GENS; i++) {
160 :     ratio = DfltRatios[i];
161 :     if (i == 0)
162 :     max_sz = MAX_SZ1(params->allocSz * MAX_NUM_PROCS);
163 : jhr 1247 else {
164 :     max_sz = (5*max_sz)/2;
165 :     if (max_sz > 64*ONE_MEG) max_sz = 64*ONE_MEG;
166 :     }
167 : monnier 249 gen =
168 :     heap->gen[i] = NEW_OBJ(gen_t);
169 :     gen->heap = heap;
170 :     gen->genNum = i+1;
171 :     gen->numGCs = 0;
172 :     gen->lastPrevGC = 0;
173 :     gen->ratio = ratio;
174 :     gen->toObj = NIL(mem_obj_t *);
175 :     gen->fromObj = NIL(mem_obj_t *);
176 :     gen->cacheObj = NIL(mem_obj_t *);
177 :     gen->dirty = NIL(card_map_t *);
178 :     for (j = 0; j < NUM_ARENAS; j++) {
179 :     gen->arena[j] = NEW_OBJ(arena_t);
180 :     gen->arena[j]->tospSizeB = 0;
181 :     gen->arena[j]->reqSizeB = 0;
182 :     gen->arena[j]->maxSizeB = max_sz;
183 :     gen->arena[j]->id = MAKE_AID(i+1, j+1, 0);
184 :     }
185 :     for (j = 0; j < NUM_BIGOBJ_KINDS; j++)
186 :     gen->bigObjs[j] = NIL(bigobj_desc_t *);
187 :     }
188 :     for (i = 0; i < params->numGens; i++) {
189 :     int k = (i == params->numGens-1) ? i : i+1;
190 :     for (j = 0; j < NUM_ARENAS; j++)
191 :     heap->gen[i]->arena[j]->nextGen = heap->gen[k]->arena[j];
192 :     }
193 :     heap->numGens = params->numGens;
194 :     heap->cacheGen = params->cacheGen;
195 :     heap->numMinorGCs = 0;
196 :     heap->numBORegions = 0;
197 :     heap->bigRegions = NIL(bigobj_region_t *);
198 :     heap->freeBigObjs = NEW_OBJ(bigobj_desc_t);
199 :     heap->freeBigObjs->obj = (Addr_t)0;
200 :     heap->freeBigObjs->sizeB = 0;
201 :     heap->freeBigObjs->state = BO_FREE;
202 :     heap->freeBigObjs->prev = heap->freeBigObjs;
203 :     heap->freeBigObjs->next = heap->freeBigObjs;
204 :     heap->weakList = NIL(ml_val_t *);
205 :    
206 :     /* initialize new space */
207 :     heap->baseObj = baseObj;
208 :     heap->allocBase = allocBase;
209 :     heap->allocSzB = MAX_NUM_PROCS*params->allocSz;
210 :     MarkRegion (BIBOP, (ml_val_t *)BIBOP, MEMOBJ_SZB(heap->baseObj), AID_NEW);
211 :     #ifdef VERBOSE
212 :     SayDebug ("NewSpace = [%#x, %#x:%#x), %d bytes\n",
213 :     heap->allocBase, HEAP_LIMIT(heap),
214 :     (Word_t)(heap->allocBase)+params->allocSz, params->allocSz);
215 :     #endif
216 :    
217 :     #ifdef GC_STATS
218 :     ClearGCStats (heap);
219 :     #endif
220 :     #if defined(COLLECT_STATS)
221 :     if (StatsFD > 0) {
222 :     stat_hdr_t hdr;
223 :     CNTR_ZERO(&(heap->numAlloc));
224 :     hdr.mask = STATMASK_ALLOC|STATMASK_NGENS|STATMASK_START|STATMASK_STOP;
225 :     hdr.isNewRuntime = 1;
226 :     hdr.allocSzB = params->allocSz;
227 :     hdr.numGens = params->numGens;
228 :     gettimeofday (&(hdr.startTime), NIL(struct timezone *));
229 :     write (StatsFD, (char *)&hdr, sizeof(stat_hdr_t));
230 :     }
231 :     #endif
232 :    
233 :     if (isBoot) {
234 :     /* Create the first generation's to-space. */
235 :     for (i = 0; i < NUM_ARENAS; i++)
236 :     heap->gen[0]->arena[i]->tospSizeB = RND_MEMOBJ_SZB(2 * heap->allocSzB);
237 :     if (NewGeneration(heap->gen[0]) == FAILURE)
238 :     Die ("unable to allocate initial first generation space\n");
239 :     for (i = 0; i < NUM_ARENAS; i++)
240 :     heap->gen[0]->arena[i]->oldTop = heap->gen[0]->arena[i]->tospBase;
241 :     }
242 :    
243 :     /* initialize the GC related parts of the ML state */
244 :     msp->ml_heap = heap;
245 :     msp->ml_allocPtr = (ml_val_t *)(msp->ml_allocArena);
246 :     #ifdef SOFT_POLL
247 :     ResetPollLimit (msp);
248 :     #else
249 :     msp->ml_limitPtr = HEAP_LIMIT(heap);
250 :     #endif
251 :    
252 :     } /* end of InitHeap */
253 :    
254 :    
255 :     #ifdef GC_STATS
256 :     /* ClearGCStats:
257 :     */
258 :     void ClearGCStats (heap_t *heap)
259 :     {
260 :     int i, j;
261 :    
262 :     CNTR_ZERO(&(heap->numAlloc));
263 :     for (i = 0; i < MAX_NUM_GENS; i++) {
264 :     for (j = 0; j < NUM_ARENAS; j++) {
265 :     CNTR_ZERO(&(heap->numCopied[i][j]));
266 :     }
267 :     }
268 :    
269 :     } /* end of ClearStats */
270 :     #endif
271 :    

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