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 249 - (view) (download) (as text)
Original Path: sml/branches/SMLNJ/src/runtime/kernel/ml-state.c

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 :     ml_state_t *msp;
34 :     int i;
35 :    
36 :     #ifdef MP_SUPPORT
37 :     for (i = 0; i < MAX_NUM_PROCS; i++) {
38 :     if (((VProc[i] = NEW_OBJ(vproc_state_t)) == NIL(vproc_state_t *))
39 :     || ((msp = NEW_OBJ(ml_state_t)) == NIL(ml_state_t *))) {
40 :     Die ("unable to allocate ML state vectors");
41 :     }
42 :     VProc[i]->vp_state = msp;
43 :     }
44 :     msp = VProc[0]->vp_state;
45 :     #else
46 :     if (((VProc[0] = NEW_OBJ(vproc_state_t)) == NIL (vproc_state_t *))
47 :     || ((msp = NEW_OBJ(ml_state_t)) == NIL(ml_state_t *))) {
48 :     Die ("unable to allocate ML state vector");
49 :     }
50 :     VProc[0]->vp_state = msp;
51 :     #endif /* MP_SUPPORT */
52 :    
53 :     /* allocate and initialize the heap data structures */
54 :     InitHeap (msp, isBoot, heapParams);
55 :    
56 :     #ifdef MP_SUPPORT
57 :     /* partition the allocation arena given by InitHeap among the
58 :     * MAX_NUM_PROCS processors.
59 :     */
60 :     NumVProcs = MAX_NUM_PROCS;
61 :     PartitionAllocArena(VProc);
62 :     /* initialize the per-processor ML state */
63 :     for (i = 0; i < MAX_NUM_PROCS; i++) {
64 :     int j;
65 :    
66 :     InitVProcState (VProc[i]);
67 :     /* single timers are currently shared among multiple processors */
68 :     if (i != 0) {
69 :     VProc[i]->vp_gcTime0 = VProc[0]->vp_gcTime0;
70 :     VProc[i]->vp_gcTime = VProc[0]->vp_gcTime;
71 :     }
72 :     }
73 :     /* initialize the first processor here */
74 :     VProc[0]->vp_mpSelf = MP_ProcId ();
75 :     VProc[0]->vp_mpState = MP_PROC_RUNNING;
76 :     #else
77 :     InitVProcState (VProc[0]);
78 :     NumVProcs = 1;
79 :     #endif /* MP_SUPPORT */
80 :    
81 :     /* initialize the timers */
82 :     /** MP_SUPPORT note: for now, only proc 0 has timers **/
83 :     ResetTimers (VProc[0]);
84 :    
85 :     return msp;
86 :    
87 :     } /* end of AllocMLState */
88 :    
89 :     /* InitVProcState:
90 :     */
91 :     PVT void InitVProcState (vproc_state_t *vsp)
92 :     {
93 :     int i;
94 :    
95 :     vsp->vp_heap = vsp->vp_state->ml_heap;
96 :     vsp->vp_state->ml_vproc = vsp;
97 :     vsp->vp_inMLFlag = FALSE;
98 :     vsp->vp_handlerPending = FALSE;
99 :     vsp->vp_inSigHandler = FALSE;
100 :     vsp->vp_numPendingSysSigs = 0;
101 :     vsp->vp_numPendingSigs = 0;
102 :     vsp->vp_sigCode = 0;
103 :     vsp->vp_sigCount = 0;
104 :     vsp->vp_nextPendingSig = 0;
105 :     vsp->vp_numInQ = 0;
106 :     vsp->vp_gcSigState = ML_SIG_IGNORE;
107 :     vsp->vp_gcTime0 = NEW_OBJ(Time_t);
108 :     vsp->vp_gcTime = NEW_OBJ(Time_t);
109 :    
110 :     for (i = 0; i < NUM_SIGS; i++) {
111 :     vsp->vp_pendingSigQ[i].sigNum = 0;
112 :     vsp->vp_pendingSigQ[i].count = 0;
113 :     }
114 :    
115 :     /* initialize the ML state, including the roots */
116 :     InitMLState (vsp->vp_state);
117 :     vsp->vp_state->ml_arg = ML_unit;
118 :     vsp->vp_state->ml_cont = ML_unit;
119 :     vsp->vp_state->ml_closure = ML_unit;
120 :     vsp->vp_state->ml_linkReg = ML_unit;
121 :     vsp->vp_state->ml_pc = ML_unit;
122 :     vsp->vp_state->ml_exnCont = ML_unit;
123 :     vsp->vp_state->ml_varReg = ML_unit;
124 :     vsp->vp_state->ml_calleeSave[0] = ML_unit;
125 :     vsp->vp_state->ml_calleeSave[1] = ML_unit;
126 :     vsp->vp_state->ml_calleeSave[2] = ML_unit;
127 :    
128 :     #ifdef MP_SUPPORT
129 :     vsp->vp_mpSelf = 0;
130 :     vsp->vp_mpState = MP_PROC_NO_PROC;
131 :     #endif
132 :    
133 :     } /* end of InitVProcState */
134 :    
135 :     /* InitMLState:
136 :     *
137 :     * Initialize the ML State vector. Note that we do not initialize the root
138 :     * registers here, since this is sometimes called when the roots are live (from
139 :     * ML_ApplyFn).
140 :     */
141 :     void InitMLState (ml_state_t *msp)
142 :     {
143 :     int i;
144 :    
145 :     msp->ml_storePtr = ML_unit;
146 :     #ifdef SOFT_POLL
147 :     msp->ml_pollPending = FALSE;
148 :     msp->ml_inPollHandler = FALSE;
149 :     #endif
150 :    
151 :     } /* end of InitMLState. */
152 :    
153 :     /* SaveCState:
154 :     *
155 :     * Build a return closure that will save a collection of ML values
156 :     * being used by C. The ML values are passed by reference, with NIL
157 :     * as termination.
158 :     */
159 :     void SaveCState (ml_state_t *msp, ...)
160 :     {
161 :     va_list ap;
162 :     int n, i;
163 :     ml_val_t *vp;
164 :     extern ml_val_t return_a[];
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