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/kernel/ml-state.c
ViewVC logotype

Annotation of /sml/trunk/src/runtime/kernel/ml-state.c

Parent Directory Parent Directory | Revision Log Revision Log


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

1 : monnier 249 /* ml-state.c
2 :     *
3 :     * COPYRIGHT (c) 1993 by AT&T Bell Laboratories.
4 :     *
5 :     */
6 :    
7 :     #include <stdarg.h>
8 :     #include "ml-base.h"
9 :     #include "vproc-state.h"
10 :     #include "ml-state.h"
11 :     #include "system-signals.h"
12 :     #include "tags.h"
13 :     #include "ml-values.h"
14 :     #include "ml-objects.h"
15 :     #include "ml-globals.h"
16 :     #include "gc.h"
17 :     #include "ml-timer.h"
18 :     #include "ml-limits.h"
19 :    
20 :    
21 :     vproc_state_t *VProc[MAX_NUM_PROCS];
22 :     int NumVProcs;
23 :    
24 :    
25 :     /* local routines */
26 :     PVT void InitVProcState (vproc_state_t *vsp);
27 :    
28 :    
29 :     /* AllocMLState:
30 :     */
31 :     ml_state_t *AllocMLState (bool_t isBoot, heap_params_t *heapParams)
32 :     {
33 : blume 569 ml_state_t *msp = NIL(ml_state_t *);
34 :     #ifdef MP_SUPPORT
35 : monnier 249 int i;
36 : blume 569 #endif
37 : monnier 249
38 :     #ifdef MP_SUPPORT
39 : blume 569
40 : monnier 249 for (i = 0; i < MAX_NUM_PROCS; i++) {
41 :     if (((VProc[i] = NEW_OBJ(vproc_state_t)) == NIL(vproc_state_t *))
42 :     || ((msp = NEW_OBJ(ml_state_t)) == NIL(ml_state_t *))) {
43 :     Die ("unable to allocate ML state vectors");
44 :     }
45 :     VProc[i]->vp_state = msp;
46 :     }
47 :     msp = VProc[0]->vp_state;
48 :     #else
49 :     if (((VProc[0] = NEW_OBJ(vproc_state_t)) == NIL (vproc_state_t *))
50 :     || ((msp = NEW_OBJ(ml_state_t)) == NIL(ml_state_t *))) {
51 :     Die ("unable to allocate ML state vector");
52 :     }
53 :     VProc[0]->vp_state = msp;
54 :     #endif /* MP_SUPPORT */
55 :    
56 :     /* allocate and initialize the heap data structures */
57 :     InitHeap (msp, isBoot, heapParams);
58 :    
59 :     #ifdef MP_SUPPORT
60 :     /* partition the allocation arena given by InitHeap among the
61 :     * MAX_NUM_PROCS processors.
62 :     */
63 :     NumVProcs = MAX_NUM_PROCS;
64 :     PartitionAllocArena(VProc);
65 :     /* initialize the per-processor ML state */
66 :     for (i = 0; i < MAX_NUM_PROCS; i++) {
67 :     int j;
68 :    
69 :     InitVProcState (VProc[i]);
70 :     /* single timers are currently shared among multiple processors */
71 :     if (i != 0) {
72 :     VProc[i]->vp_gcTime0 = VProc[0]->vp_gcTime0;
73 :     VProc[i]->vp_gcTime = VProc[0]->vp_gcTime;
74 :     }
75 :     }
76 :     /* initialize the first processor here */
77 :     VProc[0]->vp_mpSelf = MP_ProcId ();
78 :     VProc[0]->vp_mpState = MP_PROC_RUNNING;
79 :     #else
80 :     InitVProcState (VProc[0]);
81 :     NumVProcs = 1;
82 :     #endif /* MP_SUPPORT */
83 :    
84 :     /* initialize the timers */
85 :     /** MP_SUPPORT note: for now, only proc 0 has timers **/
86 :     ResetTimers (VProc[0]);
87 :    
88 :     return msp;
89 :    
90 :     } /* end of AllocMLState */
91 :    
92 :     /* InitVProcState:
93 :     */
94 :     PVT void InitVProcState (vproc_state_t *vsp)
95 :     {
96 :     int i;
97 :    
98 :     vsp->vp_heap = vsp->vp_state->ml_heap;
99 :     vsp->vp_state->ml_vproc = vsp;
100 :     vsp->vp_inMLFlag = FALSE;
101 :     vsp->vp_handlerPending = FALSE;
102 :     vsp->vp_inSigHandler = FALSE;
103 :     vsp->vp_numPendingSysSigs = 0;
104 :     vsp->vp_numPendingSigs = 0;
105 :     vsp->vp_sigCode = 0;
106 :     vsp->vp_sigCount = 0;
107 :     vsp->vp_nextPendingSig = 0;
108 :     vsp->vp_numInQ = 0;
109 :     vsp->vp_gcSigState = ML_SIG_IGNORE;
110 :     vsp->vp_gcTime0 = NEW_OBJ(Time_t);
111 :     vsp->vp_gcTime = NEW_OBJ(Time_t);
112 :    
113 :     for (i = 0; i < NUM_SIGS; i++) {
114 :     vsp->vp_pendingSigQ[i].sigNum = 0;
115 :     vsp->vp_pendingSigQ[i].count = 0;
116 :     }
117 :    
118 :     /* initialize the ML state, including the roots */
119 :     InitMLState (vsp->vp_state);
120 :     vsp->vp_state->ml_arg = ML_unit;
121 :     vsp->vp_state->ml_cont = ML_unit;
122 :     vsp->vp_state->ml_closure = ML_unit;
123 :     vsp->vp_state->ml_linkReg = ML_unit;
124 :     vsp->vp_state->ml_pc = ML_unit;
125 :     vsp->vp_state->ml_exnCont = ML_unit;
126 :     vsp->vp_state->ml_varReg = ML_unit;
127 :     vsp->vp_state->ml_calleeSave[0] = ML_unit;
128 :     vsp->vp_state->ml_calleeSave[1] = ML_unit;
129 :     vsp->vp_state->ml_calleeSave[2] = ML_unit;
130 :    
131 :     #ifdef MP_SUPPORT
132 :     vsp->vp_mpSelf = 0;
133 :     vsp->vp_mpState = MP_PROC_NO_PROC;
134 :     #endif
135 :    
136 :     } /* end of InitVProcState */
137 :    
138 :     /* InitMLState:
139 :     *
140 :     * Initialize the ML State vector. Note that we do not initialize the root
141 :     * registers here, since this is sometimes called when the roots are live (from
142 :     * ML_ApplyFn).
143 :     */
144 :     void InitMLState (ml_state_t *msp)
145 :     {
146 :     msp->ml_storePtr = ML_unit;
147 :     #ifdef SOFT_POLL
148 :     msp->ml_pollPending = FALSE;
149 :     msp->ml_inPollHandler = FALSE;
150 :     #endif
151 :    
152 :     } /* end of InitMLState. */
153 :    
154 :     /* SaveCState:
155 :     *
156 :     * Build a return closure that will save a collection of ML values
157 :     * being used by C. The ML values are passed by reference, with NIL
158 :     * as termination.
159 :     */
160 :     void SaveCState (ml_state_t *msp, ...)
161 :     {
162 :     va_list ap;
163 :     int n, i;
164 :     ml_val_t *vp;
165 :    
166 :     va_start (ap, msp);
167 :     for (n = 0; (vp = va_arg(ap, ml_val_t *)) != NIL(ml_val_t *); n++)
168 :     continue;
169 :     va_end (ap);
170 :    
171 :     va_start (ap, msp);
172 :     ML_AllocWrite (msp, 0, MAKE_DESC(n, DTAG_record));
173 :     for (i = 1; i <= n; i++) {
174 :     vp = va_arg (ap, ml_val_t *);
175 :     ML_AllocWrite (msp, i, *vp);
176 :     }
177 :     msp->ml_calleeSave[0] = ML_Alloc(msp, n);
178 :     msp->ml_cont = PTR_CtoML(return_c);
179 :     va_end (ap);
180 :    
181 :     } /* end of SaveCState */
182 :    
183 :     /* RestoreCState:
184 :     *
185 :     * Restore a collection of ML values from the return closure.
186 :     */
187 :     void RestoreCState (ml_state_t *msp, ...)
188 :     {
189 :     va_list ap;
190 :     int n, i;
191 :     ml_val_t *vp;
192 :     ml_val_t savedState;
193 :    
194 :     va_start (ap, msp);
195 :     savedState = msp->ml_calleeSave[0];
196 :     n = OBJ_LEN(savedState);
197 :     for (i = 0; i < n; i++) {
198 :     vp = va_arg (ap, ml_val_t *);
199 :     *vp = REC_SEL(savedState, i);
200 :     }
201 :     va_end (ap);
202 :    
203 :     } /* end of RestoreCState */
204 :    

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