Mercurial > cgi-bin > hgwebdir.cgi > VMS > VMS_Implementations > VSs_impls > VSs__MC_shared_impl
changeset 27:3b30da4643d1 ML_dev
Update2.. in middle of changes.. made request handler ptr be sent w/req struct
| author | Sean Halle <seanhalle@yahoo.com> |
|---|---|
| date | Sat, 12 Jan 2013 11:31:51 -0800 |
| parents | a60399b62614 |
| children | 91caa8a9d591 |
| files | Measurement/VSs_Counter_Recording.c Measurement/VSs_Measurement.h VSs.c VSs.h VSs_PluginFns.c VSs_Request_Handlers.c VSs_Request_Handlers.h VSs_SS.c |
| diffstat | 8 files changed, 847 insertions(+), 463 deletions(-) [+] |
line diff
1.1 --- a/Measurement/VSs_Counter_Recording.c Thu Oct 18 02:44:30 2012 -0700 1.2 +++ b/Measurement/VSs_Counter_Recording.c Sat Jan 12 11:31:51 2013 -0800 1.3 @@ -11,11 +11,11 @@ 1.4 1.5 void VSs__init_counter_data_structs( SlaveVP *slave ) 1.6 { 1.7 - VSsSemEnv *semanticEnv = 1.8 - (VSsSemEnv *)PR_SS__give_sem_env_for( slave, VSs_MAGIC_NUMBER ); 1.9 + VSsLangEnv *langEnv = 1.10 + (VSsLangEnv *)PR_SS__give_lang_env_for_slave( slave, VSs_MAGIC_NUMBER ); 1.11 int i; 1.12 for(i=0;i<NUM_CORES;i++) 1.13 - { semanticEnv->counterList[i] = makeListOfArrays(sizeof(CounterEvent), 128); 1.14 + { langEnv->counterList[i] = makeListOfArrays(sizeof(CounterEvent), 128); 1.15 } 1.16 } 1.17 1.18 @@ -38,7 +38,7 @@ 1.19 return; 1.20 } 1.21 1.22 - VSsSemEnv *semanticEnv = _PRMasterEnv->semanticEnv; 1.23 + VSsLangEnv *langEnv = _PRTopEnv->protoLangEnv; 1.24 1.25 CounterEvent e; 1.26 e.event_type = evt_type; 1.27 @@ -61,9 +61,9 @@ 1.28 if(pr) corenum = pr->coreAnimatedBy; else return; 1.29 1.30 if(evt_type==Work_start || evt_type==Work_end || evt_type==AppResponderInvocation_start){ 1.31 - addToListOfArrays_ext(CounterEvent,e,semanticEnv->counterList[corenum]); 1.32 + addToListOfArrays_ext(CounterEvent,e,langEnv->counterList[corenum]); 1.33 } else { 1.34 - addToListOfArraysCounterEvent(e,semanticEnv->counterList[corenum]); 1.35 + addToListOfArraysCounterEvent(e,langEnv->counterList[corenum]); 1.36 } 1.37 } 1.38
2.1 --- a/Measurement/VSs_Measurement.h Thu Oct 18 02:44:30 2012 -0700 2.2 +++ b/Measurement/VSs_Measurement.h Sat Jan 12 11:31:51 2013 -0800 2.3 @@ -1,5 +1,5 @@ 2.4 /* 2.5 - * Copyright 2009 OpenSourceStewardshipFoundation.org 2.6 + * Copyright 2009 OpenSourceResearchInstitute.org 2.7 * Licensed under GNU General Public License version 2 2.8 * 2.9 * Author: seanhalle@yahoo.com 2.10 @@ -26,8 +26,8 @@ 2.11 #define ReceiveOfTypeHistIdx 4 2.12 2.13 #define MEAS__Make_Meas_Hists_for_Language \ 2.14 - _PRMasterEnv->measHistsInfo = \ 2.15 - makePrivDynArrayOfSize( (void***)&(_PRMasterEnv->measHists), 200); \ 2.16 + _PRTopEnv->measHistsInfo = \ 2.17 + makePrivDynArrayOfSize( (void***)&(_PRTopEnv->measHists), 200); \ 2.18 makeAMeasHist( SendFromToHistIdx, "SendFromTo", 50, 0, 100 ) \ 2.19 makeAMeasHist( SendOfTypeHistIdx, "SendOfType", 50, 0, 100 ) \ 2.20 makeAMeasHist( ReceiveFromToHistIdx,"ReceiveFromTo", 50, 0, 100 ) \ 2.21 @@ -40,7 +40,7 @@ 2.22 #define Meas_endSendFromTo \ 2.23 saveLowTimeStampCountInto( endStamp ); \ 2.24 addIntervalToHist( startStamp, endStamp, \ 2.25 - _PRMasterEnv->measHists[ SendFromToHistIdx ] ); 2.26 + _PRTopEnv->measHists[ SendFromToHistIdx ] ); 2.27 2.28 #define Meas_startSendOfType \ 2.29 int32 startStamp, endStamp; \ 2.30 @@ -49,7 +49,7 @@ 2.31 #define Meas_endSendOfType \ 2.32 saveLowTimeStampCountInto( endStamp ); \ 2.33 addIntervalToHist( startStamp, endStamp, \ 2.34 - _PRMasterEnv->measHists[ SendOfTypeHistIdx ] ); 2.35 + _PRTopEnv->measHists[ SendOfTypeHistIdx ] ); 2.36 2.37 #define Meas_startReceiveFromTo \ 2.38 int32 startStamp, endStamp; \ 2.39 @@ -58,7 +58,7 @@ 2.40 #define Meas_endReceiveFromTo \ 2.41 saveLowTimeStampCountInto( endStamp ); \ 2.42 addIntervalToHist( startStamp, endStamp, \ 2.43 - _PRMasterEnv->measHists[ ReceiveFromToHistIdx ] ); 2.44 + _PRTopEnv->measHists[ ReceiveFromToHistIdx ] ); 2.45 2.46 #define Meas_startReceiveOfType \ 2.47 int32 startStamp, endStamp; \ 2.48 @@ -67,7 +67,7 @@ 2.49 #define Meas_endReceiveOfType \ 2.50 saveLowTimeStampCountInto( endStamp ); \ 2.51 addIntervalToHist( startStamp, endStamp, \ 2.52 - _PRMasterEnv->measHists[ReceiveOfTypeHistIdx ] ); 2.53 + _PRTopEnv->measHists[ReceiveOfTypeHistIdx ] ); 2.54 2.55 #else //===================== turned off ========================== 2.56
3.1 --- a/VSs.c Thu Oct 18 02:44:30 2012 -0700 3.2 +++ b/VSs.c Sat Jan 12 11:31:51 2013 -0800 3.3 @@ -15,6 +15,12 @@ 3.4 #include "Measurement/VSs_Counter_Recording.h" 3.5 3.6 //========================================================================== 3.7 +void 3.8 +VSs__init_Helper(); 3.9 + 3.10 +SlaveVP * 3.11 +VSs__create_thread_w_ID_and_affinity( TopLevelFnPtr fnPtr, void *initData, 3.12 + int32 *thdID, int32 coreToAssignOnto, SlaveVP *creatingThd ); 3.13 3.14 //========================================================================== 3.15 3.16 @@ -75,12 +81,12 @@ 3.17 * saves jump point, and second jumps back several times to get reliable time 3.18 */ 3.19 void 3.20 -VSs__begin_primitive() 3.21 - { VSsSemData *semData; 3.22 +VSs__begin_primitive( SlaveVP *animSlv ) 3.23 + { VSsLangData *langData; 3.24 3.25 - semData = (VSsSemData *)PR_WL__give_sem_data( animSlv, VSs_MAGIC_NUMBER); 3.26 + langData = (VSsLangData *)PR_WL__give_lang_data( animSlv, VSs_MAGIC_NUMBER); 3.27 3.28 - saveLowTimeStampCountInto( semData->primitiveStartTime ); 3.29 + saveLowTimeStampCountInto( langData->primitiveStartTime ); 3.30 } 3.31 3.32 /*Just quick and dirty for now -- make reliable later 3.33 @@ -89,22 +95,18 @@ 3.34 * also to throw out any "weird" values due to OS interrupt or TSC rollover 3.35 */ 3.36 int32 3.37 -VSs__end_primitive_and_give_cycles( SlaveVP animSlv ) 3.38 +VSs__end_primitive_and_give_cycles( SlaveVP *animSlv ) 3.39 { int32 endTime, startTime; 3.40 - VSsSemData *semData; 3.41 + VSsLangData *langData; 3.42 3.43 //TODO: fix by repeating time-measurement 3.44 saveLowTimeStampCountInto( endTime ); 3.45 - semData = (VSsSemData *)PR_WL__give_sem_data( animSlv, VSs_MAGIC_NUMBER); 3.46 - startTime = semData->primitiveStartTime; 3.47 + langData = (VSsLangData *)PR_WL__give_lang_data( animSlv, VSs_MAGIC_NUMBER); 3.48 + startTime = langData->primitiveStartTime; 3.49 return (endTime - startTime); 3.50 } 3.51 3.52 3.53 -//=========================================================================== 3.54 - 3.55 - 3.56 - 3.57 3.58 //=========================================================================== 3.59 3.60 @@ -124,21 +126,44 @@ 3.61 ANY_CORE, creatingThd ); 3.62 } 3.63 3.64 +/* old version -- looks safe to delete 3.65 +SlaveVP * 3.66 +VSs__create_slave_with_affinity( TopLevelFnPtr fnPtr, void *initData, 3.67 + SlaveVP *creatingSlv, int32 coreToAssignOnto ) 3.68 + { VSsLangReq reqData; 3.69 + 3.70 + //the lang request data is on the stack and disappears when this 3.71 + // call returns -- it's guaranteed to remain in the VP's stack for as 3.72 + // long as the VP is suspended. 3.73 + reqData.reqType = create_slave_w_aff; //not used, May 2012 3.74 + reqData.coreToAssignOnto = coreToAssignOnto; 3.75 + reqData.fnPtr = fnPtr; 3.76 + reqData.initData = initData; 3.77 + reqData.callingSlv = creatingSlv; 3.78 + 3.79 + PR_WL__send_create_slaveVP_req( &reqData, creatingSlv, VSs_MAGIC_NUMBER ); 3.80 + 3.81 + return creatingSlv->dataRetFromReq; 3.82 + } 3.83 +*/ 3.84 + 3.85 3.86 SlaveVP * 3.87 VSs__create_thread_w_ID_and_affinity( TopLevelFnPtr fnPtr, void *initData, 3.88 int32 *thdID, int32 coreToAssignOnto, SlaveVP *creatingThd ) 3.89 - { VSsSemReq reqData; 3.90 + { VSsLangReq reqData; 3.91 3.92 - //the semantic request data is on the stack and disappears when this 3.93 + //the lang request data is on the stack and disappears when this 3.94 // call returns -- it's guaranteed to remain in the VP's stack for as 3.95 // long as the VP is suspended. 3.96 - reqData.reqType = create_slave; //know type because in a PR create req 3.97 - reqData.coreToAssignOnto = coreToAssignOnto; 3.98 + reqData.reqType = create_slave; //know type because in a PR create req 3.99 + reqData.coreToAssignOnto = coreToAssignOnto; 3.100 + reqData.fnPtr = fnPtr; 3.101 + reqData.initData = initData; 3.102 3.103 - PR_WL__send_create_slaveVP_req( &reqData, fnPtr, initData, thdID, 3.104 + PR_WL__send_create_slaveVP_req( &reqData, thdID, &handleCreateThd, 3.105 creatingThd, VSs_MAGIC_NUMBER ); 3.106 - return creatingThd->dataRetFromReq; 3.107 + return (SlaveVP *)creatingThd->dataRetFromReq; 3.108 } 3.109 3.110 /*This is always the last thing done in the code animated by a thread VP. 3.111 @@ -151,7 +176,8 @@ 3.112 void 3.113 VSs__end_thread( SlaveVP *thdToEnd ) 3.114 { 3.115 - PR_WL__send_dissipate_req( thdToEnd, VSs_MAGIC_NUMBER ); 3.116 + //the lang request is null for VSs version of end slave 3.117 + PR_WL__send_end_slave_req( NULL, &handleDissipate, thdToEnd, VSs_MAGIC_NUMBER ); 3.118 } 3.119 3.120 3.121 @@ -164,7 +190,7 @@ 3.122 */ 3.123 void 3.124 VSs__submit_task( VSsTaskType *taskType, void *args, SlaveVP *animSlv) 3.125 - { VSsSemReq reqData; 3.126 + { VSsLangReq reqData; 3.127 3.128 reqData.reqType = submit_task; 3.129 3.130 @@ -175,13 +201,14 @@ 3.131 //Create task is a special form, so have to pass as parameters, the 3.132 // top-level-fn of task and the data for that fn, plus lang's req, 3.133 // animating slave, and lang's magic number 3.134 - PR_WL__send_create_task_req( taskType->fn, args, &reqData, NO_ID, animSlv, VSs_MAGIC_NUMBER ); 3.135 + PR_WL__send_create_task_req( taskType->fn, args, &reqData, NO_ID, 3.136 + &handleSubmitTask, animSlv, VSs_MAGIC_NUMBER ); 3.137 } 3.138 3.139 void 3.140 VSs__submit_task_with_ID( VSsTaskType *taskType, void *args, int32 *taskID, 3.141 - SlaveVP *animSlv) 3.142 - { VSsSemReq reqData; 3.143 + SlaveVP *animSlv ) 3.144 + { VSsLangReq reqData; 3.145 3.146 reqData.reqType = submit_task; 3.147 3.148 @@ -189,7 +216,8 @@ 3.149 reqData.args = args; 3.150 reqData.callingSlv = animSlv; 3.151 3.152 - PR_WL__send_create_task_req( taskType->fn, args, &reqData, taskID, animSlv, VSs_MAGIC_NUMBER ); 3.153 + PR_WL__send_create_task_req( taskType->fn, args, &reqData, taskID, 3.154 + &handleSubmitTask, animSlv, VSs_MAGIC_NUMBER ); 3.155 } 3.156 3.157 3.158 @@ -212,12 +240,10 @@ 3.159 */ 3.160 void 3.161 VSs__end_task( SlaveVP *animSlv ) 3.162 - { VSsSemReq reqData; 3.163 - 3.164 - reqData.reqType = end_task; 3.165 - reqData.callingSlv = animSlv; 3.166 + { VSsLangReq reqData; 3.167 3.168 - PR_WL__send_end_task_request( &reqData, animSlv, VSs_MAGIC_NUMBER ); 3.169 + //VSs has nothing extra to communicate to end task handler, so lang req is NULL 3.170 + PR_WL__send_end_task_request( NULL, &handleEndTask, animSlv, VSs_MAGIC_NUMBER ); 3.171 } 3.172 3.173 3.174 @@ -227,12 +253,12 @@ 3.175 void 3.176 VSs__taskwait(SlaveVP *animSlv) 3.177 { 3.178 - VSsSemReq reqData; 3.179 + VSsLangReq reqData; 3.180 3.181 reqData.reqType = taskwait; 3.182 reqData.callingSlv = animSlv; 3.183 3.184 - PR_WL__send_sem_request( &reqData, animSlv, VSs_MAGIC_NUMBER ); 3.185 + PR_WL__send_lang_request( &reqData, &handleTaskwait, animSlv, VSs_MAGIC_NUMBER ); 3.186 } 3.187 3.188 3.189 @@ -243,7 +269,7 @@ 3.190 inline int32 * 3.191 VSs__give_self_taskID( SlaveVP *animSlv ) 3.192 { 3.193 - return PR__give_task_ID( animSlv, VSs_MAGIC_NUMBER ); 3.194 + return PR__give_ID_from_slave( animSlv, VSs_MAGIC_NUMBER ); 3.195 } 3.196 3.197 //================================ send =================================== 3.198 @@ -251,7 +277,7 @@ 3.199 void 3.200 VSs__send_of_type_to( void *msg, const int32 type, int32 *receiverID, 3.201 SlaveVP *senderSlv ) 3.202 - { VSsSemReq reqData; 3.203 + { VSsLangReq reqData; 3.204 3.205 reqData.reqType = send_type_to; 3.206 3.207 @@ -262,14 +288,14 @@ 3.208 3.209 reqData.nextReqInHashEntry = NULL; 3.210 3.211 - PR_WL__send_sem_request( &reqData, senderSlv, VSs_MAGIC_NUMBER ); 3.212 + PR_WL__send_lang_request( &reqData, &handleSendTypeTo, senderSlv, VSs_MAGIC_NUMBER ); 3.213 3.214 //When come back from suspend, no longer own data reachable from msg 3.215 } 3.216 3.217 void 3.218 VSs__send_from_to( void *msg, int32 *senderID, int32 *receiverID, SlaveVP *senderSlv ) 3.219 - { VSsSemReq reqData; 3.220 + { VSsLangReq reqData; 3.221 3.222 reqData.reqType = send_from_to; 3.223 3.224 @@ -280,7 +306,7 @@ 3.225 3.226 reqData.nextReqInHashEntry = NULL; 3.227 3.228 - PR_WL__send_sem_request( &reqData, senderSlv, VSs_MAGIC_NUMBER ); 3.229 + PR_WL__send_lang_request( &reqData, &handleSendFromTo, senderSlv, VSs_MAGIC_NUMBER ); 3.230 } 3.231 3.232 3.233 @@ -295,7 +321,7 @@ 3.234 void * 3.235 VSs__receive_type_to( const int32 type, int32* receiverID, SlaveVP *receiverSlv ) 3.236 { DEBUG__printf1(dbgRqstHdlr,"WL: receive type to %d",receiverID[1] ); 3.237 - VSsSemReq reqData; 3.238 + VSsLangReq reqData; 3.239 3.240 reqData.reqType = receive_type_to; 3.241 3.242 @@ -305,7 +331,7 @@ 3.243 3.244 reqData.nextReqInHashEntry = NULL; 3.245 3.246 - PR_WL__send_sem_request( &reqData, receiverSlv, VSs_MAGIC_NUMBER ); 3.247 + PR_WL__send_lang_request( &reqData, &handleReceiveTypeTo, receiverSlv, VSs_MAGIC_NUMBER ); 3.248 3.249 return receiverSlv->dataRetFromReq; 3.250 } 3.251 @@ -319,7 +345,7 @@ 3.252 void * 3.253 VSs__receive_from_to( int32 *senderID, int32 *receiverID, SlaveVP *receiverSlv ) 3.254 { 3.255 - VSsSemReq reqData; 3.256 + VSsLangReq reqData; 3.257 3.258 reqData.reqType = receive_from_to; 3.259 3.260 @@ -330,7 +356,7 @@ 3.261 reqData.nextReqInHashEntry = NULL; 3.262 DEBUG__printf2(dbgRqstHdlr,"WL: receive from %d to: %d", reqData.senderID[1], reqData.receiverID[1]); 3.263 3.264 - PR_WL__send_sem_request( &reqData, receiverSlv, VSs_MAGIC_NUMBER ); 3.265 + PR_WL__send_lang_request( &reqData, &handleReceiveFromTo, receiverSlv, VSs_MAGIC_NUMBER ); 3.266 3.267 return receiverSlv->dataRetFromReq; 3.268 } 3.269 @@ -355,22 +381,23 @@ 3.270 void asm_write_ret_from_singleton(VSsSingleton *singletonPtrAddr); 3.271 3.272 /*Fn singleton uses ID as index into array of singleton structs held in the 3.273 - * semantic environment. 3.274 + * language environment. 3.275 */ 3.276 void 3.277 VSs__start_fn_singleton( int32 singletonID, SlaveVP *animSlv ) 3.278 { 3.279 - VSsSemReq reqData; 3.280 + VSsLangReq reqData; 3.281 3.282 // 3.283 reqData.reqType = singleton_fn_start; 3.284 reqData.singletonID = singletonID; 3.285 3.286 - PR_WL__send_sem_request( &reqData, animSlv, VSs_MAGIC_NUMBER ); 3.287 + PR_WL__send_lang_request( &reqData, &handleStartFnSingleton, animSlv, VSs_MAGIC_NUMBER ); 3.288 if( animSlv->dataRetFromReq ) //will be 0 or addr of label in end singleton 3.289 { 3.290 - VSsSemEnv *semEnv = PR_WL__give_sem_env_for( animSlv, VSs_MAGIC_NUMBER ); 3.291 - asm_write_ret_from_singleton(&(semEnv->fnSingletons[ singletonID])); 3.292 + VSsLangEnv *langEnv = 3.293 + PR_int__give_lang_env_for_slave__ML( animSlv, VSs_MAGIC_NUMBER ); 3.294 + asm_write_ret_from_singleton(&(langEnv->fnSingletons[ singletonID])); 3.295 } 3.296 } 3.297 3.298 @@ -381,7 +408,7 @@ 3.299 void 3.300 VSs__start_data_singleton( VSsSingleton **singletonAddr, SlaveVP *animSlv ) 3.301 { 3.302 - VSsSemReq reqData; 3.303 + VSsLangReq reqData; 3.304 3.305 if( *singletonAddr && (*singletonAddr)->hasFinished ) 3.306 goto JmpToEndSingleton; 3.307 @@ -389,7 +416,7 @@ 3.308 reqData.reqType = singleton_data_start; 3.309 reqData.singletonPtrAddr = singletonAddr; 3.310 3.311 - PR_WL__send_sem_request( &reqData, animSlv, VSs_MAGIC_NUMBER ); 3.312 + PR_WL__send_lang_request( &reqData, &handleStartDataSingleton, animSlv, VSs_MAGIC_NUMBER ); 3.313 if( animSlv->dataRetFromReq ) //either 0 or end singleton's return addr 3.314 { //Assembly code changes the return addr on the stack to the one 3.315 // saved into the singleton by the end-singleton-fn 3.316 @@ -410,17 +437,19 @@ 3.317 void 3.318 VSs__end_fn_singleton( int32 singletonID, SlaveVP *animSlv ) 3.319 { 3.320 - VSsSemReq reqData; 3.321 + VSsLangReq reqData; 3.322 3.323 //don't need this addr until after at least one singleton has reached 3.324 // this function 3.325 - VSsSemEnv *semEnv = PR_WL__give_sem_env_for( animSlv, VSs_MAGIC_NUMBER ); 3.326 - asm_write_ret_from_singleton(&(semEnv->fnSingletons[ singletonID])); 3.327 + VSsLangEnv * 3.328 + langEnv = PR_int__give_lang_env_for_slave__ML( animSlv, VSs_MAGIC_NUMBER ); 3.329 + 3.330 + asm_write_ret_from_singleton(&(langEnv->fnSingletons[ singletonID])); 3.331 3.332 reqData.reqType = singleton_fn_end; 3.333 reqData.singletonID = singletonID; 3.334 3.335 - PR_WL__send_sem_request( &reqData, animSlv, VSs_MAGIC_NUMBER ); 3.336 + PR_WL__send_lang_request( &reqData, &handleEndFnSingleton, animSlv, VSs_MAGIC_NUMBER ); 3.337 3.338 EndSingletonInstrAddr: 3.339 return; 3.340 @@ -429,7 +458,7 @@ 3.341 void 3.342 VSs__end_data_singleton( VSsSingleton **singletonPtrAddr, SlaveVP *animSlv ) 3.343 { 3.344 - VSsSemReq reqData; 3.345 + VSsLangReq reqData; 3.346 3.347 //don't need this addr until after singleton struct has reached 3.348 // this function for first time 3.349 @@ -442,7 +471,7 @@ 3.350 reqData.reqType = singleton_data_end; 3.351 reqData.singletonPtrAddr = singletonPtrAddr; 3.352 3.353 - PR_WL__send_sem_request( &reqData, animSlv, VSs_MAGIC_NUMBER ); 3.354 + PR_WL__send_lang_request( &reqData, &handleEndDataSingleton, animSlv, VSs_MAGIC_NUMBER ); 3.355 } 3.356 3.357 /*This executes the function in the masterVP, so it executes in isolation 3.358 @@ -459,14 +488,14 @@ 3.359 VSs__animate_short_fn_in_isolation( PtrToAtomicFn ptrToFnToExecInMaster, 3.360 void *data, SlaveVP *animSlv ) 3.361 { 3.362 - VSsSemReq reqData; 3.363 + VSsLangReq reqData; 3.364 3.365 // 3.366 reqData.reqType = atomic; 3.367 reqData.fnToExecInMaster = ptrToFnToExecInMaster; 3.368 reqData.dataForFn = data; 3.369 3.370 - PR_WL__send_sem_request( &reqData, animSlv, VSs_MAGIC_NUMBER ); 3.371 + PR_WL__send_lang_request( &reqData, &handleAtomic, animSlv, VSs_MAGIC_NUMBER ); 3.372 } 3.373 3.374 3.375 @@ -486,14 +515,14 @@ 3.376 void 3.377 VSs__start_transaction( int32 transactionID, SlaveVP *animSlv ) 3.378 { 3.379 - VSsSemReq reqData; 3.380 + VSsLangReq reqData; 3.381 3.382 // 3.383 reqData.callingSlv = animSlv; 3.384 reqData.reqType = trans_start; 3.385 reqData.transID = transactionID; 3.386 3.387 - PR_WL__send_sem_request( &reqData, animSlv, VSs_MAGIC_NUMBER ); 3.388 + PR_WL__send_lang_request( &reqData, &handleTransStart, animSlv, VSs_MAGIC_NUMBER ); 3.389 } 3.390 3.391 /*This suspends to the master, then uses transactionID as index into an 3.392 @@ -508,36 +537,15 @@ 3.393 void 3.394 VSs__end_transaction( int32 transactionID, SlaveVP *animSlv ) 3.395 { 3.396 - VSsSemReq reqData; 3.397 + VSsLangReq reqData; 3.398 3.399 // 3.400 reqData.callingSlv = animSlv; 3.401 reqData.reqType = trans_end; 3.402 reqData.transID = transactionID; 3.403 3.404 - PR_WL__send_sem_request( &reqData, animSlv, VSs_MAGIC_NUMBER ); 3.405 + PR_WL__send_lang_request( &reqData, &handleTransEnd, animSlv, VSs_MAGIC_NUMBER ); 3.406 } 3.407 3.408 //======================== Internal ================================== 3.409 -/* 3.410 - */ 3.411 3.412 -SlaveVP * 3.413 -VSs__create_slave_with_affinity( TopLevelFnPtr fnPtr, void *initData, 3.414 - SlaveVP *creatingSlv, int32 coreToAssignOnto ) 3.415 - { VSsSemReq reqData; 3.416 - 3.417 - //the semantic request data is on the stack and disappears when this 3.418 - // call returns -- it's guaranteed to remain in the VP's stack for as 3.419 - // long as the VP is suspended. 3.420 - reqData.reqType = create_slave_w_aff; //not used, May 2012 3.421 - reqData.coreToAssignOnto = coreToAssignOnto; 3.422 - reqData.fnPtr = fnPtr; 3.423 - reqData.initData = initData; 3.424 - reqData.callingSlv = creatingSlv; 3.425 - 3.426 - PR_WL__send_create_slaveVP_req( &reqData, creatingSlv, VSs_MAGIC_NUMBER ); 3.427 - 3.428 - return creatingSlv->dataRetFromReq; 3.429 - } 3.430 -
4.1 --- a/VSs.h Thu Oct 18 02:44:30 2012 -0700 4.2 +++ b/VSs.h Sat Jan 12 11:31:51 2013 -0800 4.3 @@ -1,5 +1,5 @@ 4.4 /* 4.5 - * Copyright 2009 OpenSourceStewardshipFoundation.org 4.6 + * Copyright 2009 OpenSourceResearchInstitute.org 4.7 * Licensed under GNU General Public License version 2 4.8 * 4.9 * Author: seanhalle@yahoo.com 4.10 @@ -19,7 +19,7 @@ 4.11 //uniquely identifies VSs -- should be a jenkins char-hash of "VSs" to int32 4.12 #define VSs_MAGIC_NUMBER 0000000001 4.13 4.14 -#define NUM_STRUCS_IN_SEM_ENV 1000 4.15 +#define NUM_STRUCS_IN_LANG_ENV 1000 4.16 4.17 //This is hardware dependent -- it's the number of cycles of scheduling 4.18 // overhead -- if a work unit is fewer than this, it is better being 4.19 @@ -31,7 +31,7 @@ 4.20 //=========================================================================== 4.21 /*This header defines everything specific to the VSs semantic plug-in 4.22 */ 4.23 -typedef struct _VSsSemReq VSsSemReq; 4.24 +typedef struct _VSsLangReq VSsLangReq; 4.25 typedef struct _VSsTaskStub VSsTaskStub; 4.26 typedef void (*VSsTaskFnPtr ) ( void *, SlaveVP *); 4.27 typedef void (*PtrToAtomicFn ) ( void * ); //executed atomically in master 4.28 @@ -73,11 +73,13 @@ 4.29 } 4.30 VSsPointerEntry; 4.31 4.32 -/*This is placed into semData, used for dependencies and wait construct*/ 4.33 +/*This is placed into langData, used for dependencies and wait construct*/ 4.34 struct _VSsTaskStub 4.35 { 4.36 + //====== The first fields must match PRLangMetaTask fields ====== 4.37 int32 langMagicNumber; //magic num must be 1st field of langMetaTask 4.38 PRMetaTask *protoMetaTask; //back-link must always be 2nd field 4.39 + //====== end PRLangMetaTask fields ========= 4.40 void **args; //ctld args must be the first ones (as ptrs) 4.41 VSsPointerEntry **ptrEntries; 4.42 int32 numBlockingProp; 4.43 @@ -149,7 +151,7 @@ 4.44 trans_end 4.45 }; 4.46 4.47 -struct _VSsSemReq 4.48 +struct _VSsLangReq 4.49 { enum VSsReqType reqType; 4.50 SlaveVP *callingSlv; 4.51 VSsTaskType *taskType; 4.52 @@ -162,7 +164,7 @@ 4.53 int32 *receiverID; 4.54 int32 msgType; 4.55 void *msg; 4.56 - VSsSemReq *nextReqInHashEntry; 4.57 + VSsLangReq *nextReqInHashEntry; 4.58 //In PRReq: int32 *taskID; 4.59 4.60 TopLevelFnPtr fnPtr; 4.61 @@ -181,31 +183,22 @@ 4.62 4.63 int32 transID; 4.64 } 4.65 -/* VSsSemReq */; 4.66 +/* VSsLangReq */; 4.67 4.68 4.69 typedef struct 4.70 - { PRSemEnv *protoSemEnv; 4.71 + { 4.72 PrivQueueStruc *slavesReadyToResumeQ; //Shared (slaves not pinned) 4.73 - PrivQueueStruc *freeTaskSlvRecycleQ; //Shared 4.74 PrivQueueStruc *taskReadyQ; //Shared (tasks not pinned) 4.75 -// SlaveVP *slotTaskSlvs[NUM_CORES][NUM_ANIM_SLOTS]; 4.76 + 4.77 HashTable *argPtrHashTbl; 4.78 HashTable *commHashTbl; 4.79 -// int32 numLiveFreeTaskSlvs; 4.80 -// int32 numLiveThreadSlvs; 4.81 int32 nextCoreToGetNewSlv; 4.82 int32 primitiveStartTime; 4.83 4.84 //fix limit on num with dynArray 4.85 - VSsSingleton fnSingletons[NUM_STRUCS_IN_SEM_ENV]; 4.86 - VSsTrans transactionStrucs[NUM_STRUCS_IN_SEM_ENV]; 4.87 - 4.88 -// bool32 *coreIsDone; 4.89 -// int32 numCoresDone; 4.90 - 4.91 -// SlaveVP* idleSlv[NUM_CORES][NUM_ANIM_SLOTS]; 4.92 -// int shutdownInitiated; 4.93 + VSsSingleton fnSingletons[NUM_STRUCS_IN_LANG_ENV]; 4.94 + VSsTrans transactionStrucs[NUM_STRUCS_IN_LANG_ENV]; 4.95 4.96 #ifdef HOLISTIC__TURN_ON_OBSERVE_UCC 4.97 ListOfArrays* unitList; 4.98 @@ -222,7 +215,7 @@ 4.99 ListOfArrays* counterList[NUM_CORES]; 4.100 #endif 4.101 } 4.102 -VSsSemEnv; 4.103 +VSsLangEnv; 4.104 4.105 4.106 typedef struct _TransListElem TransListElem; 4.107 @@ -248,7 +241,7 @@ 4.108 int32 primitiveStartTime; 4.109 // VSsTaskStub *taskStub; //get from slave via PR accessor 4.110 } 4.111 -VSsSemData; 4.112 +VSsLangData; 4.113 4.114 //=========================================================================== 4.115 4.116 @@ -355,18 +348,14 @@ 4.117 4.118 //========================= Internal use only ============================= 4.119 void 4.120 -VSs__Request_Handler( SlaveVP *requestingSlv, void *_semEnv ); 4.121 +VSs__Request_Handler( SlaveVP *requestingSlv, void *_langEnv ); 4.122 4.123 SlaveVP * 4.124 -VSs__assign_slaveVP_to_slot( void *_semEnv, AnimSlot *slot ); 4.125 +VSs__assign_work_to_slot( void *_langEnv, AnimSlot *slot ); 4.126 4.127 SlaveVP* 4.128 VSs__create_slave_helper( TopLevelFnPtr fnPtr, void *initData, 4.129 - VSsSemEnv *semEnv, int32 coreToAssignOnto ); 4.130 - 4.131 -PRMetaTask * 4.132 -PR_int__create_generic_slave_meta_task( void *initData ); 4.133 - 4.134 + VSsLangEnv *langEnv, int32 coreToAssignOnto ); 4.135 4.136 SlaveVP * 4.137 VSs__create_slave_with( TopLevelFnPtr fnPtr, void *initData, 4.138 @@ -376,6 +365,15 @@ 4.139 VSs__create_slave_with_affinity( TopLevelFnPtr fnPtr, void *initData, 4.140 SlaveVP *creatingSlv, int32 coreToAssignOnto); 4.141 4.142 +//===================== ===================== 4.143 +inline 4.144 +void * 4.145 +handleSubmitTask( VSsLangReq *langReq, VSsLangEnv *langEnv ); 4.146 +inline 4.147 +void 4.148 +handleEndTask( VSsLangReq *langReq, SlaveVP *requestingSlv, VSsLangEnv *langEnv ); 4.149 + 4.150 + 4.151 //===================== Measurement of Lang Overheads ===================== 4.152 #include "Measurement/VSs_Measurement.h" 4.153
5.1 --- a/VSs_PluginFns.c Thu Oct 18 02:44:30 2012 -0700 5.2 +++ b/VSs_PluginFns.c Sat Jan 12 11:31:51 2013 -0800 5.3 @@ -13,16 +13,16 @@ 5.4 5.5 //=========================== Local Fn Prototypes =========================== 5.6 void 5.7 -resume_slaveVP( SlaveVP *slave, VSsSemEnv *semEnv ); 5.8 +resume_slaveVP( SlaveVP *slave, VSsLangEnv *langEnv ); 5.9 5.10 inline void 5.11 -handleSemReq( PRReqst *req, SlaveVP *requestingSlv, VSsSemEnv *semEnv ); 5.12 +handleLangReq( PRReqst *req, SlaveVP *requestingSlv, VSsLangEnv *langEnv ); 5.13 5.14 inline void 5.15 -handleDissipate( SlaveVP *requestingSlv, VSsSemEnv *semEnv ); 5.16 +handleDissipate( SlaveVP *requestingSlv, VSsLangEnv *langEnv ); 5.17 5.18 inline void 5.19 -handleCreate( PRReqst *req, SlaveVP *requestingSlv, VSsSemEnv *semEnv ); 5.20 +handleCreate( PRReqst *req, SlaveVP *requestingSlv, VSsLangEnv *langEnv ); 5.21 5.22 //============================== Assigner ================================== 5.23 // 5.24 @@ -52,28 +52,31 @@ 5.25 * the junk tasks are allowed to leave behind. 5.26 */ 5.27 SlaveVP * 5.28 -VSs__assign_slaveVP_to_slot( void *_semEnv, AnimSlot *slot ) 5.29 +VSs__assign_work_to_slot( void *_langEnv, AnimSlot *slot ) 5.30 { SlaveVP *returnSlv; 5.31 - VSsSemEnv *semEnv; 5.32 + VSsLangEnv *langEnv; 5.33 int32 coreNum, slotNum; 5.34 - PRMetaTask *returnMetaTask = NULL, *newTaskStub; 5.35 + PRMetaTask *returnMetaTask = NULL; 5.36 + VSsTaskStub *newTaskStub; 5.37 5.38 coreNum = slot->coreSlotIsOn; 5.39 slotNum = slot->slotIdx; 5.40 5.41 - semEnv = (VSsSemEnv *)_semEnv; 5.42 + langEnv = (VSsLangEnv *)_langEnv; 5.43 5.44 //Check for suspended slaves that are ready to resume 5.45 - returnSlv = readPrivQ( semEnv->slavesReadyToResumeQ ); 5.46 + returnSlv = readPrivQ( langEnv->slavesReadyToResumeQ ); 5.47 if( returnSlv != NULL ) //Yes, have a slave, so return it. 5.48 { returnSlv->coreAnimatedBy = coreNum; 5.49 - returnMetaTask = returnSlv->metaTask; 5.50 + //returnMetaTask = returnSlv->metaTask; 5.51 + fixme; //use PR_int__put_slave_into_slot( SlaveVP *slave, AnimSlot *slot ) 5.52 goto ReturnTheMetaTask; 5.53 } 5.54 5.55 - newTaskStub = readPrivQ( semEnv->taskReadyQ ); 5.56 + newTaskStub = readPrivQ( langEnv->taskReadyQ ); 5.57 if( newTaskStub != NULL ) 5.58 - { returnMetaTask = newTaskStub->protoMetaTask; 5.59 + { //returnMetaTask = newTaskStub->protoMetaTask; 5.60 + fixme; //use PR_int__put_task_into_slot( SlaveVP *slave, AnimSlot *slot ) 5.61 goto ReturnTheMetaTask; 5.62 } 5.63 5.64 @@ -84,44 +87,48 @@ 5.65 //This assumes the task has already been assigned to a slave, which happens 5.66 // inside Master.. 5.67 if( returnMetaTask == NULL ) 5.68 - { returnSlv = semEnv->process->idleSlv[coreNum][slotNum]; 5.69 + { returnSlv = langEnv->process->idleSlv[coreNum][slotNum]; 5.70 5.71 //things that would normally happen in resume(), but these VPs 5.72 // never go there 5.73 returnSlv->numTimesAssignedToASlot++; 5.74 Unit newU; 5.75 - newU.vp = returnSlv->slaveID; 5.76 + newU.vp = returnSlv->slaveNum; 5.77 newU.task = returnSlv->numTimesAssignedToASlot; 5.78 - addToListOfArrays(Unit,newU,semEnv->unitList); 5.79 + addToListOfArrays(Unit,newU,langEnv->unitList); 5.80 5.81 if (returnSlv->numTimesAssignedToASlot > 1) 5.82 { Dependency newD; 5.83 - newD.from_vp = returnSlv->slaveID; 5.84 + newD.from_vp = returnSlv->slaveNum; 5.85 newD.from_task = returnSlv->numTimesAssignedToASlot - 1; 5.86 - newD.to_vp = returnSlv->slaveID; 5.87 + newD.to_vp = returnSlv->slaveNum; 5.88 newD.to_task = returnSlv->numTimesAssignedToASlot; 5.89 - addToListOfArrays(Dependency, newD, semEnv->ctlDependenciesList); 5.90 + addToListOfArrays(Dependency, newD, langEnv->ctlDependenciesList); 5.91 } 5.92 returnMetaTask = returnSlv->metaTask; 5.93 } 5.94 else //returnSlv != NULL 5.95 { //assignSlv->numTimesAssigned++; 5.96 Unit prev_in_slot = 5.97 - semEnv->last_in_slot[coreNum * NUM_ANIM_SLOTS + slotNum]; 5.98 + langEnv->last_in_slot[coreNum * NUM_ANIM_SLOTS + slotNum]; 5.99 if(prev_in_slot.vp != 0) 5.100 { Dependency newD; 5.101 newD.from_vp = prev_in_slot.vp; 5.102 newD.from_task = prev_in_slot.task; 5.103 - newD.to_vp = returnSlv->slaveID; 5.104 + newD.to_vp = returnSlv->slaveNum; 5.105 newD.to_task = returnSlv->numTimesAssignedToASlot; 5.106 - addToListOfArrays(Dependency,newD,semEnv->hwArcs); 5.107 + addToListOfArrays(Dependency,newD,langEnv->hwArcs); 5.108 } 5.109 - prev_in_slot.vp = returnSlv->slaveID; 5.110 + prev_in_slot.vp = returnSlv->slaveNum; 5.111 prev_in_slot.task = returnSlv->numTimesAssignedToASlot; 5.112 - semEnv->last_in_slot[coreNum * NUM_ANIM_SLOTS + slotNum] = 5.113 + langEnv->last_in_slot[coreNum * NUM_ANIM_SLOTS + slotNum] = 5.114 prev_in_slot; 5.115 } 5.116 #endif 5.117 + if( isEmptyPrivQ(langEnv->slavesReadyToResumeQ) && 5.118 + isEmptyPrivQ(langEnv->taskReadyQ) ) 5.119 + PR_int__clear_work_in_lang_env(langEnv); 5.120 + 5.121 return( returnMetaTask ); 5.122 } 5.123 5.124 @@ -133,42 +140,43 @@ 5.125 */ 5.126 5.127 void 5.128 -handleSemReq( PRReqst *req, SlaveVP *reqSlv, VSsSemEnv *semEnv ) 5.129 - { VSsSemReq *semReq; 5.130 +handleLangReq( void *_langReq, SlaveVP *reqSlv, VSsLangEnv *langEnv ) 5.131 + { VSsLangReq *langReq; 5.132 5.133 - semReq = PR_PI__take_sem_reqst_from(req); 5.134 - if( semReq == NULL ) return; 5.135 - switch( semReq->reqType ) //sem handlers are all in other file 5.136 + langReq = (VSsLangReq *)_langReq; 5.137 + if( langReq == NULL ) return; 5.138 + 5.139 + switch( langReq->reqType ) //lang handlers are all in other file 5.140 { 5.141 - case send_type_to: handleSendTypeTo( semReq, semEnv); 5.142 + case send_type_to: handleSendTypeTo( langReq, langEnv); 5.143 break; 5.144 - case send_from_to: handleSendFromTo( semReq, semEnv); 5.145 + case send_from_to: handleSendFromTo( langReq, langEnv); 5.146 break; 5.147 - case receive_type_to: handleReceiveTypeTo(semReq, semEnv); 5.148 + case receive_type_to: handleReceiveTypeTo(langReq, langEnv); 5.149 break; 5.150 - case receive_from_to: handleReceiveFromTo(semReq, semEnv); 5.151 + case receive_from_to: handleReceiveFromTo(langReq, langEnv); 5.152 break; 5.153 - case taskwait: handleTaskwait( semReq, reqSlv, semEnv); 5.154 + case taskwait: handleTaskwait( langReq, reqSlv, langEnv); 5.155 break; 5.156 5.157 //==================================================================== 5.158 - case malloc_req: handleMalloc( semReq, reqSlv, semEnv); 5.159 + case malloc_req: handleMalloc( langReq, reqSlv, langEnv); 5.160 break; 5.161 - case free_req: handleFree( semReq, reqSlv, semEnv); 5.162 + case free_req: handleFree( langReq, reqSlv, langEnv); 5.163 break; 5.164 - case singleton_fn_start: handleStartFnSingleton(semReq, reqSlv, semEnv); 5.165 + case singleton_fn_start: handleStartFnSingleton(langReq, reqSlv, langEnv); 5.166 break; 5.167 - case singleton_fn_end: handleEndFnSingleton( semReq, reqSlv, semEnv); 5.168 + case singleton_fn_end: handleEndFnSingleton( langReq, reqSlv, langEnv); 5.169 break; 5.170 - case singleton_data_start:handleStartDataSingleton(semReq,reqSlv,semEnv); 5.171 + case singleton_data_start:handleStartDataSingleton(langReq,reqSlv,langEnv); 5.172 break; 5.173 - case singleton_data_end: handleEndDataSingleton(semReq, reqSlv, semEnv); 5.174 + case singleton_data_end: handleEndDataSingleton(langReq, reqSlv, langEnv); 5.175 break; 5.176 - case atomic: handleAtomic( semReq, reqSlv, semEnv); 5.177 + case atomic: handleAtomic( langReq, reqSlv, langEnv); 5.178 break; 5.179 - case trans_start: handleTransStart( semReq, reqSlv, semEnv); 5.180 + case trans_start: handleTransStart( langReq, reqSlv, langEnv); 5.181 break; 5.182 - case trans_end: handleTransEnd( semReq, reqSlv, semEnv); 5.183 + case trans_end: handleTransEnd( langReq, reqSlv, langEnv); 5.184 break; 5.185 } 5.186 } 5.187 @@ -178,12 +186,11 @@ 5.188 5.189 //=========================== Helper ============================== 5.190 void 5.191 -resume_slaveVP( SlaveVP *slave, VSsSemEnv *semEnv ) 5.192 +resume_slaveVP( SlaveVP *slave, VSsLangEnv *langEnv ) 5.193 { 5.194 //both suspended tasks and suspended explicit slaves resumed with this 5.195 - writePrivQ( slave, semEnv->slavesReadyToResumeQ ); 5.196 - if( semEnv->protoSemEnv->hasWork != TRUE ) 5.197 - semEnv->protoSemEnv->hasWork = TRUE; 5.198 + writePrivQ( slave, langEnv->slavesReadyToResumeQ ); 5.199 + PR_int__set_work_in_lang_env(langEnv); 5.200 5.201 #ifdef HOLISTIC__TURN_ON_PERF_COUNTERS 5.202 /* 5.203 @@ -195,17 +202,17 @@ 5.204 #ifdef HOLISTIC__TURN_ON_OBSERVE_UCC 5.205 slave->numTimesAssignedToASlot++; //Somewhere here! 5.206 Unit newU; 5.207 - newU.vp = slave->slaveID; 5.208 + newU.vp = slave->slaveNum; 5.209 newU.task = slave->numTimesAssignedToASlot; 5.210 - addToListOfArrays(Unit,newU,semEnv->unitList); 5.211 + addToListOfArrays(Unit,newU,langEnv->unitList); 5.212 5.213 if (slave->numTimesAssignedToASlot > 1) 5.214 { Dependency newD; 5.215 - newD.from_vp = slave->slaveID; 5.216 + newD.from_vp = slave->slaveNum; 5.217 newD.from_task = slave->numTimesAssignedToASlot - 1; 5.218 - newD.to_vp = slave->slaveID; 5.219 + newD.to_vp = slave->slaveNum; 5.220 newD.to_task = slave->numTimesAssignedToASlot; 5.221 - addToListOfArrays(Dependency, newD ,semEnv->ctlDependenciesList); 5.222 + addToListOfArrays(Dependency, newD ,langEnv->ctlDependenciesList); 5.223 } 5.224 #endif 5.225 }
6.1 --- a/VSs_Request_Handlers.c Thu Oct 18 02:44:30 2012 -0700 6.2 +++ b/VSs_Request_Handlers.c Sat Jan 12 11:31:51 2013 -0800 6.3 @@ -18,7 +18,7 @@ 6.4 6.5 //=========================== Local Fn Prototypes =========================== 6.6 void 6.7 -resume_slaveVP( SlaveVP *slave, VSsSemEnv *semEnv ); 6.8 +resume_slaveVP( SlaveVP *slave, VSsLangEnv *langEnv ); 6.9 6.10 6.11 6.12 @@ -28,15 +28,15 @@ 6.13 6.14 /*Only clone the elements of req used in these reqst handlers 6.15 */ 6.16 -VSsSemReq * 6.17 -cloneReq( VSsSemReq *semReq ) 6.18 - { VSsSemReq *clonedReq; 6.19 +VSsLangReq * 6.20 +cloneReq( VSsLangReq *langReq ) 6.21 + { VSsLangReq *clonedReq; 6.22 6.23 - clonedReq = PR_PI__malloc( sizeof(VSsSemReq) ); 6.24 - clonedReq->reqType = semReq->reqType; 6.25 - clonedReq->senderSlv = semReq->senderSlv; 6.26 - clonedReq->receiverSlv= semReq->receiverSlv; 6.27 - clonedReq->msg = semReq->msg; 6.28 + clonedReq = PR_PI__malloc( sizeof(VSsLangReq) ); 6.29 + clonedReq->reqType = langReq->reqType; 6.30 + clonedReq->senderSlv = langReq->senderSlv; 6.31 + clonedReq->receiverSlv= langReq->receiverSlv; 6.32 + clonedReq->msg = langReq->msg; 6.33 clonedReq->nextReqInHashEntry = NULL; 6.34 6.35 return clonedReq; 6.36 @@ -45,29 +45,30 @@ 6.37 6.38 6.39 HashEntry * 6.40 -giveEntryElseInsertReqst32( int32 *key, VSsSemReq *semReq, 6.41 +giveEntryElseInsertReqst32( int32 *key, VSsLangReq *langReq, 6.42 HashTable *commHashTbl ) 6.43 { HashEntry *entry; 6.44 - VSsSemReq *waitingReq; 6.45 + VSsLangReq *waitingReq; 6.46 6.47 entry = getEntryFromTable32( key, commHashTbl ); 6.48 if( entry == NULL ) 6.49 { //no waiting sends or receives, so add this request and exit 6.50 // note: have to clone the request because it's on stack of sender 6.51 - addValueIntoTable32( key, cloneReq( semReq ), commHashTbl ); 6.52 + addValueIntoTable32( key, cloneReq( langReq ), commHashTbl ); 6.53 return NULL; 6.54 } 6.55 - waitingReq = (VSsSemReq *)entry->content; 6.56 + waitingReq = (VSsLangReq *)entry->content; 6.57 if( waitingReq == NULL ) //might happen when last waiting gets paired 6.58 { //no waiting sends or receives, so add this request and exit 6.59 - entry->content = semReq; 6.60 + entry->content = langReq; 6.61 return NULL; 6.62 } 6.63 return entry; 6.64 } 6.65 6.66 6.67 -inline VSsPointerEntry * 6.68 +inline 6.69 +VSsPointerEntry * 6.70 create_pointer_entry( ) 6.71 { VSsPointerEntry *newEntry; 6.72 6.73 @@ -82,28 +83,55 @@ 6.74 /*malloc's space and initializes fields -- and COPIES the arg values 6.75 * to new space 6.76 */ 6.77 -inline VSsTaskStub * 6.78 +inline 6.79 +VSsTaskStub * 6.80 create_task_stub( VSsTaskType *taskType, void **args ) 6.81 { void **newArgs; 6.82 - VSsTaskStub* newStub = PR_int__malloc( sizeof(PRMetaTask) + taskType->sizeOfArgs ); 6.83 - newStub->numBlockingProp = taskType->numCtldArgs; 6.84 - newStub->taskType = taskType; 6.85 + VSsTaskStub* newStub; 6.86 + 6.87 + //Create a new task stub, with enough room at end to copy args there 6.88 + newStub = (VSsTaskStub *)PR_int__create_lang_meta_task__ML( 6.89 + sizeof(VSsTaskStub) + taskType->sizeOfArgs, VSs_MAGIC_NUMBER ); 6.90 + 6.91 + newStub->numBlockingProp = taskType->numCtldArgs; 6.92 + newStub->taskType = taskType; 6.93 newStub->ptrEntries = 6.94 PR_int__malloc( taskType->numCtldArgs * sizeof(VSsPointerEntry *) ); 6.95 - newArgs = (void **)( (uint8 *)newStub + sizeof(PRMetaTask) ); 6.96 - newStub->args = newArgs; 6.97 + 6.98 + //Skip over the task stub, to get ptr to space alloc'd for args copy 6.99 + newArgs = (void **)( (uint8 *)newStub + sizeof(VSsTaskStub) ); 6.100 + newStub->args = newArgs; 6.101 newStub->numLiveChildTasks = 0; 6.102 newStub->numLiveChildThreads = 0; 6.103 - newStub->isEnded = FALSE; 6.104 + newStub->isEnded = FALSE; 6.105 6.106 - //Copy the arg-pointers.. can be more arguments than just the ones 6.107 + //Copy the args.. can be more arguments than just the ones 6.108 // that StarSs uses to control ordering of task execution. 6.109 memcpy( newArgs, args, taskType->sizeOfArgs ); 6.110 6.111 return newStub; 6.112 } 6.113 6.114 -inline VSsTaskStubCarrier * 6.115 + 6.116 +VSsTaskStub * 6.117 +VSs__create_generic_slave_task_stub_in_slave( SlaveVP *slave ) 6.118 + { VSsTaskStub *newStub; 6.119 + 6.120 + newStub = (VSsTaskStub *)PR_int__create_lang_meta_task_in_slave__ML( 6.121 + sizeof(VSsTaskStub), slave, VSs_MAGIC_NUMBER ); 6.122 + newStub->numBlockingProp = 0; 6.123 + newStub->taskType = NULL; 6.124 + newStub->ptrEntries = NULL; 6.125 + newStub->args = NULL; 6.126 + newStub->numLiveChildTasks = 0; 6.127 + newStub->numLiveChildThreads = 0; 6.128 + newStub->isEnded = FALSE; 6.129 + 6.130 + return newStub; 6.131 + } 6.132 + 6.133 +inline 6.134 +VSsTaskStubCarrier * 6.135 create_task_carrier( VSsTaskStub *taskStub, int32 argNum, int32 rdOrWrite ) 6.136 { VSsTaskStubCarrier *newCarrier; 6.137 6.138 @@ -129,17 +157,23 @@ 6.139 * 6.140 *When slave dissipates, PR will call the registered recycler for the task stub. 6.141 */ 6.142 -inline void 6.143 -handleCreateThd( PRReqst *req, SlaveVP *requestingSlv, SlaveVP *newSlv, VSsSemEnv *semEnv ) 6.144 - { VSsSemReq *semReq; 6.145 +//inline 6.146 +SlaveVP * 6.147 +handleCreateThd( void *_langReq, SlaveVP *requestingSlv, void *_langEnv ) 6.148 + { VSsLangReq *langReq; 6.149 VSsTaskStub *taskStub, *parentTaskStub; 6.150 + SlaveVP *newSlv; 6.151 + VSsLangEnv *langEnv; 6.152 + 6.153 + langReq = (VSsLangReq *) _langReq; 6.154 + langEnv = (VSsLangEnv *) _langEnv; 6.155 6.156 - semReq = PR_PI__take_sem_reqst_from( req ); 6.157 - 6.158 - parentTaskStub = PR_PI__give_lang_meta_task( requestingSlv ); 6.159 + newSlv = PR_int__create_slave( langReq->fnPtr, langReq->initData ); 6.160 + 6.161 + parentTaskStub = PR_PI__give_lang_meta_task_from_slave__ML( requestingSlv, VSs_MAGIC_NUMBER ); 6.162 parentTaskStub->numLiveChildThreads += 1; 6.163 6.164 - taskStub = create_thread_task_stub(); //only used for wait info 6.165 + taskStub = VSs__create_generic_slave_task_stub_in_slave(requestingSlv); //used for wait info 6.166 taskStub->parentTaskStub = parentTaskStub; 6.167 6.168 //note, semantic data will be initialized by separate, registered 6.169 @@ -151,15 +185,15 @@ 6.170 6.171 #else 6.172 //Assigning slaves to cores is part of SSR code.. 6.173 - int32 coreToAssignOnto = semReq->coreToAssignOnto; 6.174 + int32 coreToAssignOnto = langReq->coreToAssignOnto; 6.175 if(coreToAssignOnto < 0 || coreToAssignOnto >= NUM_CORES ) 6.176 { //out-of-range, so round-robin assignment 6.177 - newSlv->coreAnimatedBy = semEnv->nextCoreToGetNewSlv; 6.178 + newSlv->coreAnimatedBy = langEnv->nextCoreToGetNewSlv; 6.179 6.180 - if( semEnv->nextCoreToGetNewSlv >= NUM_CORES - 1 ) 6.181 - semEnv->nextCoreToGetNewSlv = 0; 6.182 + if( langEnv->nextCoreToGetNewSlv >= NUM_CORES - 1 ) 6.183 + langEnv->nextCoreToGetNewSlv = 0; 6.184 else 6.185 - semEnv->nextCoreToGetNewSlv += 1; 6.186 + langEnv->nextCoreToGetNewSlv += 1; 6.187 } 6.188 else //core num in-range, so use it 6.189 { newSlv->coreAnimatedBy = coreToAssignOnto; 6.190 @@ -170,51 +204,55 @@ 6.191 6.192 6.193 DEBUG__printf2(dbgRqstHdlr,"Create from: %d, new VP: %d", 6.194 - requestingSlv->slaveID, newSlv->slaveID) 6.195 + requestingSlv->slaveNum, newSlv->slaveNum) 6.196 6.197 #ifdef HOLISTIC__TURN_ON_OBSERVE_UCC 6.198 Dependency newD; 6.199 - newD.from_vp = requestingSlv->slaveID; 6.200 + newD.from_vp = requestingSlv->slaveNum; 6.201 newD.from_task = requestingSlv->numTimesAssignedToASlot; 6.202 - newD.to_vp = newSlv->slaveID; 6.203 + newD.to_vp = newSlv->slaveNum; 6.204 newD.to_task = 1; 6.205 - addToListOfArrays(Dependency,newD,semEnv->commDependenciesList); 6.206 + addToListOfArrays(Dependency,newD,langEnv->commDependenciesList); 6.207 #endif 6.208 6.209 //For VSs, caller needs ptr to created thread returned to it 6.210 requestingSlv->dataRetFromReq = newSlv; 6.211 - resume_slaveVP(requestingSlv , semEnv ); 6.212 - resume_slaveVP( newSlv, semEnv ); 6.213 + resume_slaveVP(requestingSlv , langEnv ); 6.214 + resume_slaveVP( newSlv, langEnv ); 6.215 + 6.216 + return newSlv; 6.217 } 6.218 6.219 /*Initialize semantic data struct.. this initializer doesn't need any input, 6.220 * but some languages may need something from inside the request that was sent 6.221 * to create a slave.. in that case, just make initializer do the malloc then 6.222 - * use the PR_PI__give_sem_data inside the create handler, and fill in the 6.223 - * semData values there. 6.224 + * use the PR_PI__give_lang_data inside the create handler, and fill in the 6.225 + * langData values there. 6.226 */ 6.227 -void * createInitialSemanticData( ) 6.228 - { VSsSemData *semData; 6.229 +void * 6.230 +createInitialSemanticData( ) 6.231 + { VSsLangData *langData; 6.232 6.233 - semData = PR_PI__malloc( sizeof(VSsSemData) ); 6.234 + langData = PR_PI__malloc( sizeof(VSsLangData) ); 6.235 6.236 - semData->highestTransEntered = -1; 6.237 - semData->lastTransEntered = NULL; 6.238 - return semData; 6.239 + langData->highestTransEntered = -1; 6.240 + langData->lastTransEntered = NULL; 6.241 + return langData; 6.242 } 6.243 6.244 /*SlaveVP dissipate -- this is NOT task-end!, only call this to end explicitly 6.245 * created threads 6.246 */ 6.247 -inline void 6.248 -handleDissipate( SlaveVP *requestingSlv, VSsSemEnv *semEnv ) 6.249 - { VSsSemData *semData; 6.250 +//inline 6.251 +void 6.252 +handleDissipate( SlaveVP *requestingSlv, VSsLangEnv *langEnv ) 6.253 + { 6.254 VSsTaskStub *parentTaskStub, *ownTaskStub; 6.255 6.256 DEBUG__printf1(dbgRqstHdlr,"Dissipate request from processor %d", 6.257 - requestingSlv->slaveID) 6.258 + requestingSlv->slaveNum) 6.259 6.260 - ownTaskStub = PR_PI__give_lang_meta_task( requestingSlv, VSs_MAGIC_NUMBER ); 6.261 + ownTaskStub = PR_PI__give_lang_meta_task_from_slave__ML( requestingSlv, VSs_MAGIC_NUMBER ); 6.262 parentTaskStub = ownTaskStub->parentTaskStub; 6.263 parentTaskStub->numLiveChildThreads -= 1; //parent wasn't freed, even if ended 6.264 6.265 @@ -233,7 +271,7 @@ 6.266 if( parentTaskStub->isWaitingForChildTasksToEnd ) 6.267 return; //still waiting on tasks (should be impossible) 6.268 else //parent free to resume 6.269 - resume_slaveVP( PR_PI__give_slave_assigned_to(parentTaskStub), semEnv ); 6.270 + resume_slaveVP( PR_PI__give_slave_lang_meta_task_assigned_to(parentTaskStub), langEnv ); 6.271 } 6.272 6.273 //check if this is last child of ended parent (note, not possible to 6.274 @@ -241,34 +279,44 @@ 6.275 if( parentTaskStub->isEnded && 6.276 parentTaskStub->numLiveChildTasks == 0 && 6.277 parentTaskStub->numLiveChildThreads == 0 ) 6.278 - { free_task_stub( parentTaskStub ); //just stub, semData already freed 6.279 + { free_task_stub( parentTaskStub ); //just stub, langData already freed 6.280 } 6.281 6.282 FreeSlaveStateAndReturn: 6.283 - //Used to free the semData and requesting slave's base state, but 6.284 - // now PR does those things, so nothing more to do.. 6.285 -//PR handles this: PR_PI__free( semData ); 6.286 -//PR handles this: PR_PI__dissipate_slaveVP( requestingSlv ); 6.287 + //PR frees the langData, task stub and requesting slave's base state 6.288 + return; 6.289 + } 6.290 +inline 6.291 +void 6.292 +handleShutdownDissipate( SlaveVP *requestingSlv, VSsLangEnv *langEnv ) 6.293 + { 6.294 + VSsTaskStub *ownTaskStub; 6.295 + 6.296 + ownTaskStub = PR_PI__give_lang_meta_task_from_slave__ML( requestingSlv, VSs_MAGIC_NUMBER ); 6.297 + free_task_stub( ownTaskStub ); 6.298 + 6.299 + //PR frees the langData, task stub and requesting slave's base state 6.300 return; 6.301 } 6.302 6.303 /*Register this with PR, during VSs start 6.304 * 6.305 - *At some point, may change PR so that it recycles semData, in which case this 6.306 + *At some point, may change PR so that it recycles langData, in which case this 6.307 * only gets called when a process shuts down.. at that point, PR will call 6.308 * dissipate on all the slaves it has in the recycle Q. 6.309 */ 6.310 void 6.311 -freeVSsSemData( void *_semData ) 6.312 +freeVSsLangData( void *_langData ) 6.313 { // 6.314 - PR_PI__free( _semData ); 6.315 + PR_PI__free( _langData ); 6.316 } 6.317 6.318 -void resetVSsSemData( void *_semData ) 6.319 - { VSsSemData *semData = (VSsSemData *)_semData; 6.320 +void 6.321 +resetVSsLangData( void *_langData ) 6.322 + { VSsLangData *langData = (VSsLangData *)_langData; 6.323 6.324 - semData->highestTransEntered = -1; 6.325 - semData->lastTransEntered = NULL; 6.326 + langData->highestTransEntered = -1; 6.327 + langData->lastTransEntered = NULL; 6.328 } 6.329 6.330 //========================================================================== 6.331 @@ -279,12 +327,12 @@ 6.332 *PR creates a PRMetaTask and passes it in. This handler adds language- 6.333 * specific stuff to it. The language-specific stuff is linked to the 6.334 * PRMetaTask, but if the task is suspended for any reason, the lang-specific 6.335 - * part is moved to the semData of the slave that is animating the task. 6.336 + * part is moved to the langData of the slave that is animating the task. 6.337 *So, while the PRMetaTask is inside the creating language's semantic 6.338 * env, waiting to be assigned to a slave for animation, the lang-specific 6.339 * task info is accessed from the PRMetaTask. But once the task suspends, 6.340 - * that lang-specific task info transfers to the slave's semData. All lang 6.341 - * constructs that want to access it must get it from the semData. 6.342 + * that lang-specific task info transfers to the slave's langData. All lang 6.343 + * constructs that want to access it must get it from the langData. 6.344 *However, taskEnd still accesses the lang-specific task info from the 6.345 * PRMetaTask, whether it suspended or not.. and the task code can access 6.346 * data to be used within the application behavior via 6.347 @@ -354,9 +402,9 @@ 6.348 * decide garbage collection of no-longer-used pointers later) 6.349 * 6.350 */ 6.351 -inline 6.352 +//inline 6.353 void * 6.354 -handleSubmitTask( VSsSemReq *semReq, VSsSemEnv *semEnv ) 6.355 +handleSubmitTask( VSsLangReq *langReq, VSsLangEnv *langEnv ) 6.356 { uint32 key[3]; 6.357 HashEntry *rawHashEntry; //has char *, but use with uint32 * 6.358 VSsPointerEntry *ptrEntry; //contents of hash table entry for an arg pointer 6.359 @@ -366,7 +414,7 @@ 6.360 VSsTaskStubCarrier *taskCarrier; 6.361 6.362 HashTable * 6.363 - argPtrHashTbl = semEnv->argPtrHashTbl; 6.364 + argPtrHashTbl = langEnv->argPtrHashTbl; 6.365 6.366 6.367 /* ========================== creation ========================== 6.368 @@ -376,19 +424,19 @@ 6.369 * inputs from the sequential portion. Note that all controlled arguments 6.370 * are pointers, and marked as controlled in the application code). 6.371 */ 6.372 - args = semReq->args; 6.373 - taskType = semReq->taskType; //this is VSs task type struct 6.374 + args = langReq->args; 6.375 + taskType = langReq->taskType; //this is VSs task type struct 6.376 taskStub = create_task_stub( taskType, args );//copies arg ptrs 6.377 6.378 taskStub->numBlockingProp = taskType->numCtldArgs; 6.379 - //PR does this (metaTask contains taskID): taskStub->taskID = semReq->taskID; 6.380 + //PR does this (metaTask contains taskID): taskStub->taskID = langReq->taskID; 6.381 6.382 - parentTaskStub = (VSsTaskStub *)PR_PI__give_lang_meta_task(semReq->callingSlv, VSs_MAGIC_NUMBER); 6.383 + parentTaskStub = (VSsTaskStub *)PR_PI__give_lang_meta_task_from_slave__ML(langReq->callingSlv, VSs_MAGIC_NUMBER); 6.384 taskStub->parentTaskStub = parentTaskStub; 6.385 parentTaskStub->numLiveChildTasks += 1; 6.386 6.387 - //DEBUG__printf3(dbgRqstHdlr,"Submit req from slaveID: %d, from task: %d, for task: %d", semReq->callingSlv->slaveID, parentSemData->taskStub->taskID[1], taskStub->taskID[1]) 6.388 - DEBUG__printf2(dbgRqstHdlr,"Submit req from slaveID: %d, for task: %d", semReq->callingSlv->slaveID, taskStub->taskID[1]) 6.389 + //DEBUG__printf3(dbgRqstHdlr,"Submit req from slaveNum: %d, from task: %d, for task: %d", langReq->callingSlv->slaveNum, parentLangData->taskStub->taskID[1], taskStub->taskID[1]) 6.390 +// DEBUG__printf2(dbgRqstHdlr,"Submit req from slaveNum: %d, for task: %d", langReq->callingSlv->slaveNum, taskStub->taskID[1]) 6.391 6.392 /*=============== Process args ================= 6.393 *The controlled arguments are processed one by one. 6.394 @@ -431,9 +479,8 @@ 6.395 * the hash-entry's count of enabled and non-finished readers.*/ 6.396 taskStub->numBlockingProp -= 1; 6.397 if( taskStub->numBlockingProp == 0 ) 6.398 - { writePrivQ( taskStub, semEnv->taskReadyQ ); 6.399 - if( semEnv->protoSemEnv->hasWork != TRUE ) 6.400 - semEnv->protoSemEnv->hasWork = TRUE; 6.401 + { writePrivQ( taskStub, langEnv->taskReadyQ ); 6.402 + PR_int__set_work_in_lang_env( langEnv ); 6.403 } 6.404 ptrEntry->numEnabledNonDoneReaders += 1; 6.405 } 6.406 @@ -456,9 +503,8 @@ 6.407 * into the readyQ.*/ 6.408 taskStub->numBlockingProp -= 1; 6.409 if( taskStub->numBlockingProp == 0 ) 6.410 - { writePrivQ( taskStub, semEnv->taskReadyQ ); 6.411 - if( semEnv->protoSemEnv->hasWork != TRUE ) 6.412 - semEnv->protoSemEnv->hasWork = TRUE; 6.413 + { writePrivQ( taskStub, langEnv->taskReadyQ ); 6.414 + PR_int__set_work_in_lang_env( langEnv ); 6.415 } 6.416 ptrEntry->hasEnabledNonFinishedWriter = TRUE; 6.417 } 6.418 @@ -471,9 +517,9 @@ 6.419 } //for argNum 6.420 6.421 //resume the parent, creator 6.422 - resume_slaveVP( semReq->callingSlv, semEnv ); 6.423 + resume_slaveVP( langReq->callingSlv, langEnv ); 6.424 6.425 - return; 6.426 + return taskStub; 6.427 } 6.428 6.429 6.430 @@ -512,25 +558,24 @@ 6.431 *TODO: Might be safe to delete an entry when task ends and waiterQ empty 6.432 * and no readers and no writers.. 6.433 */ 6.434 -inline void 6.435 -handleEndTask( void *langMetaTask, VSsSemReq *semReq, VSsSemEnv *semEnv ) 6.436 +//inline 6.437 +void 6.438 +handleEndTask( VSsLangReq *langReq, SlaveVP *requestingSlv, VSsLangEnv *langEnv ) 6.439 { VSsPointerEntry *ptrEntry; //contents of hash table entry for an arg pointer 6.440 void **args; 6.441 - VSsSemData *endingSlvSemData; 6.442 VSsTaskStub *endingTaskStub, *waitingTaskStub, *parentStub; 6.443 VSsTaskType *endingTaskType; 6.444 VSsTaskStubCarrier *waitingTaskCarrier; 6.445 VSsPointerEntry **ptrEntries; 6.446 6.447 - 6.448 -// endingTaskStub = (VSsTaskStub *)PR_PI__give_lang_spec_task_info( semReq->callingSlv ); 6.449 - 6.450 - endingTaskStub = (VSsTaskStub *)langMetaTask; 6.451 + endingTaskStub = 6.452 + (VSsTaskStub *)PR_int__give_lang_meta_task_from_slave__ML( requestingSlv, VSs_MAGIC_NUMBER ); 6.453 + 6.454 args = endingTaskStub->args; 6.455 endingTaskType = endingTaskStub->taskType; 6.456 ptrEntries = endingTaskStub->ptrEntries; //saved in stub when create 6.457 6.458 - DEBUG__printf2(dbgRqstHdlr,"EndTask req from slaveID: %d, task: %d",semReq->callingSlv->slaveID, endingTaskStub->taskID[1]) 6.459 +// DEBUG__printf2(dbgRqstHdlr,"EndTask req from slaveNum: %d, task: %d",langReq->callingSlv->slaveNum, endingTaskStub->taskID[1]) 6.460 6.461 //"wait" functionality: Check if parent was waiting on this task 6.462 parentStub = endingTaskStub->parentTaskStub; 6.463 @@ -539,7 +584,7 @@ 6.464 parentStub->numLiveChildTasks == 0) 6.465 { 6.466 parentStub->isWaitingForChildTasksToEnd = FALSE; 6.467 - resume_slaveVP( PR_PI__give_slave_assigned_to(parentStub), semEnv ); 6.468 + resume_slaveVP( PR_PI__give_slave_lang_meta_task_assigned_to(parentStub), langEnv ); 6.469 } 6.470 6.471 //Check if parent ended, and this was last descendent, then free it 6.472 @@ -583,9 +628,8 @@ 6.473 // task-stub into the readyQ. 6.474 waitingTaskStub->numBlockingProp -= 1; 6.475 if( waitingTaskStub->numBlockingProp == 0 ) 6.476 - { writePrivQ( waitingTaskStub, semEnv->taskReadyQ ); 6.477 - if( semEnv->protoSemEnv->hasWork != TRUE ) 6.478 - semEnv->protoSemEnv->hasWork = TRUE; 6.479 + { writePrivQ( waitingTaskStub, langEnv->taskReadyQ ); 6.480 + PR_int__set_work_in_lang_env( langEnv ); 6.481 } 6.482 } 6.483 } 6.484 @@ -609,9 +653,8 @@ 6.485 // If it becomes zero, then put the task-stub into the readyQ. 6.486 waitingTaskStub->numBlockingProp -= 1; 6.487 if( waitingTaskStub->numBlockingProp == 0 ) 6.488 - { writePrivQ( waitingTaskStub, semEnv->taskReadyQ ); 6.489 - if( semEnv->protoSemEnv->hasWork != TRUE ) 6.490 - semEnv->protoSemEnv->hasWork = TRUE; 6.491 + { writePrivQ( waitingTaskStub, langEnv->taskReadyQ ); 6.492 + PR_int__set_work_in_lang_env( langEnv ); 6.493 } 6.494 } 6.495 else 6.496 @@ -627,9 +670,8 @@ 6.497 // into the readyQ. 6.498 waitingTaskStub->numBlockingProp -= 1; 6.499 if( waitingTaskStub->numBlockingProp == 0 ) 6.500 - { writePrivQ( waitingTaskStub, semEnv->taskReadyQ ); 6.501 - if( semEnv->protoSemEnv->hasWork != TRUE ) 6.502 - semEnv->protoSemEnv->hasWork = TRUE; 6.503 + { writePrivQ( waitingTaskStub, langEnv->taskReadyQ ); 6.504 + PR_int__set_work_in_lang_env( langEnv ); 6.505 } 6.506 //Get next waiting task 6.507 waitingTaskCarrier = peekPrivQ( ptrEntry->waitersQ ); 6.508 @@ -653,8 +695,59 @@ 6.509 return; 6.510 } 6.511 6.512 +//inline 6.513 +void 6.514 +handleFreeTask( void *langMetaTask ) 6.515 + { VSsPointerEntry *ptrEntry; //contents of hash table entry for an arg pointer 6.516 + void **args; 6.517 + VSsTaskStub *endingTaskStub, *waitingTaskStub; 6.518 + VSsTaskType *endingTaskType; 6.519 + VSsTaskStubCarrier *waitingTaskCarrier; 6.520 + VSsPointerEntry **ptrEntries; 6.521 + 6.522 + 6.523 + endingTaskStub = (VSsTaskStub *)langMetaTask; 6.524 + args = endingTaskStub->args; 6.525 + endingTaskType = endingTaskStub->taskType; 6.526 + ptrEntries = endingTaskStub->ptrEntries; //saved in stub when create 6.527 + 6.528 + 6.529 + //Now, update state of dependents and start ready tasks 6.530 + /*The task's controlled arguments are processed one by one. 6.531 + *Processing an argument means getting arg-pointer's entry. 6.532 + */ 6.533 + int32 argNum; 6.534 + for( argNum = 0; argNum < endingTaskType->numCtldArgs; argNum++ ) 6.535 + { 6.536 + ptrEntry = ptrEntries[argNum]; 6.537 + while( TRUE ) 6.538 + { 6.539 + waitingTaskCarrier = readPrivQ( ptrEntry->waitersQ ); 6.540 + if( waitingTaskCarrier == NULL ) 6.541 + { freePrivQ( ptrEntry->waitersQ ); 6.542 + PR_int__free( ptrEntry ); 6.543 + continue; //next iter of for loop 6.544 + } 6.545 + else 6.546 + { waitingTaskStub = waitingTaskCarrier->taskStub; 6.547 + PR_int__free( waitingTaskCarrier ); 6.548 6.549 -inline void 6.550 + //Decrement the blocking propendents count of the reader's 6.551 + // task-stub. If it reaches zero, then put the task-stub 6.552 + // into the readyQ. 6.553 + waitingTaskStub->numBlockingProp -= 1; 6.554 + if( waitingTaskStub->numBlockingProp == 0 ) 6.555 + { //last ptrEntry holding the task, so free it 6.556 + free_task_stub( endingTaskStub ); 6.557 + } 6.558 + } 6.559 + }// 6.560 + }//for argnum in ending task 6.561 + } 6.562 + 6.563 + 6.564 +//inline 6.565 +void 6.566 free_task_stub( VSsTaskStub *stubToFree ) 6.567 { if(stubToFree->ptrEntries != NULL ) //a thread stub has NULL entry 6.568 { PR_PI__free( stubToFree->ptrEntries ); 6.569 @@ -667,7 +760,7 @@ 6.570 6.571 6.572 //============================ Send Handlers ============================== 6.573 -/*Send of Type -- The semantic request has the receiving task ID and Type 6.574 +/*Send of Type -- The lang request has the receiving task ID and Type 6.575 * 6.576 *Messages of a given Type have to be kept separate.. so need a separate 6.577 * entry in the hash table for each pair: receiverID, Type 6.578 @@ -677,19 +770,20 @@ 6.579 * separate tasks can send to the same receiver, and doing hash on the 6.580 * receive task, so they will stack up. 6.581 */ 6.582 -inline void 6.583 -handleSendTypeTo( VSsSemReq *semReq, VSsSemEnv *semEnv ) 6.584 +//inline 6.585 +void 6.586 +handleSendTypeTo( VSsLangReq *langReq, VSsLangEnv *langEnv ) 6.587 { SlaveVP *senderSlv, *receiverSlv; 6.588 int32 *senderID, *receiverID; 6.589 int32 *key, keySz, receiverIDNumInt; 6.590 - VSsSemReq *waitingReq; 6.591 + VSsLangReq *waitingReq; 6.592 HashEntry *entry; 6.593 - HashTable *commHashTbl = semEnv->commHashTbl; 6.594 + HashTable *commHashTbl = langEnv->commHashTbl; 6.595 6.596 - receiverID = semReq->receiverID; //For "send", know both send & recv procrs 6.597 - senderSlv = semReq->senderSlv; 6.598 + receiverID = langReq->receiverID; //For "send", know both send & recv procrs 6.599 + senderSlv = langReq->senderSlv; 6.600 6.601 - DEBUG__printf2(dbgRqstHdlr,"SendType req from sender slaveID: %d, recTask: %d", senderSlv->slaveID, receiverID[1]) 6.602 + DEBUG__printf2(dbgRqstHdlr,"SendType req from sender slaveNum: %d, recTask: %d", senderSlv->slaveNum, receiverID[1]) 6.603 6.604 6.605 receiverIDNumInt = receiverID[0] + 1; //pos 0 doesn't include itself 6.606 @@ -697,15 +791,15 @@ 6.607 key = PR_PI__malloc( keySz ); 6.608 key[0] = receiverIDNumInt + 1; //loc 0 is num int32 in key 6.609 memcpy( &key[1], receiverID, receiverIDNumInt * sizeof(int32) ); 6.610 - key[ 1 + receiverIDNumInt ] = semReq->msgType; 6.611 + key[ 1 + receiverIDNumInt ] = langReq->msgType; 6.612 6.613 - entry = giveEntryElseInsertReqst32( key, semReq, commHashTbl ); 6.614 + entry = giveEntryElseInsertReqst32( key, langReq, commHashTbl ); 6.615 if( entry == NULL ) //was just inserted, means task has to wait 6.616 { return; 6.617 } 6.618 6.619 //if here, found a waiting request with same key 6.620 - waitingReq = (VSsSemReq *)entry->content; 6.621 + waitingReq = (VSsLangReq *)entry->content; 6.622 6.623 //At this point, know have waiting request(s) -- either sends or recv 6.624 //Note, can only have max of one receive waiting, and cannot have both 6.625 @@ -714,7 +808,7 @@ 6.626 if( waitingReq->reqType == send_type_to ) 6.627 { //waiting request is another send, so stack this up on list 6.628 // but first clone the sending request so it persists. 6.629 - VSsSemReq *clonedReq = cloneReq( semReq ); 6.630 + VSsLangReq *clonedReq = cloneReq( langReq ); 6.631 clonedReq-> nextReqInHashEntry = waitingReq->nextReqInHashEntry; 6.632 waitingReq->nextReqInHashEntry = clonedReq; 6.633 DEBUG__printf2( dbgRqstHdlr, "linked requests: %p, %p ", clonedReq,\ 6.634 @@ -725,26 +819,26 @@ 6.635 { 6.636 #ifdef HOLISTIC__TURN_ON_OBSERVE_UCC 6.637 Dependency newD; 6.638 - newD.from_vp = senderID->slaveID; 6.639 + newD.from_vp = senderID->slaveNum; 6.640 newD.from_task = senderID->numTimesAssignedToASlot; 6.641 - newD.to_vp = receiverID->slaveID; 6.642 + newD.to_vp = receiverID->slaveNum; 6.643 newD.to_task = receiverID->numTimesAssignedToASlot +1; 6.644 - //(newD,semEnv->commDependenciesList); 6.645 - addToListOfArrays(Dependency,newD,semEnv->dynDependenciesList); 6.646 - int32 groupId = semReq->msgType; 6.647 - if(semEnv->ntonGroupsInfo->numInArray <= groupId){ 6.648 - makeHighestDynArrayIndexBeAtLeast(semEnv->ntonGroupsInfo, groupId); 6.649 + //(newD,langEnv->commDependenciesList); 6.650 + addToListOfArrays(Dependency,newD,langEnv->dynDependenciesList); 6.651 + int32 groupId = langReq->msgType; 6.652 + if(langEnv->ntonGroupsInfo->numInArray <= groupId){ 6.653 + makeHighestDynArrayIndexBeAtLeast(langEnv->ntonGroupsInfo, groupId); 6.654 } 6.655 - if(semEnv->ntonGroups[groupId] == NULL){ 6.656 - semEnv->ntonGroups[groupId] = new_NtoN(groupId); 6.657 + if(langEnv->ntonGroups[groupId] == NULL){ 6.658 + langEnv->ntonGroups[groupId] = new_NtoN(groupId); 6.659 } 6.660 Unit u; 6.661 - u.vp = senderID->slaveID; 6.662 + u.vp = senderID->slaveNum; 6.663 u.task = senderID->numTimesAssignedToASlot; 6.664 - addToListOfArrays(Unit,u,semEnv->ntonGroups[groupId]->senders); 6.665 - u.vp = receiverID->slaveID; 6.666 + addToListOfArrays(Unit,u,langEnv->ntonGroups[groupId]->senders); 6.667 + u.vp = receiverID->slaveNum; 6.668 u.task = receiverID->numTimesAssignedToASlot +1; 6.669 - addToListOfArrays(Unit,u,semEnv->ntonGroups[groupId]->receivers); 6.670 + addToListOfArrays(Unit,u,langEnv->ntonGroups[groupId]->receivers); 6.671 #endif 6.672 6.673 //set receiver slave, from the waiting request 6.674 @@ -763,11 +857,11 @@ 6.675 6.676 //attach msg that's in this send request to receiving task's Slv 6.677 // when comes back from suspend will have msg in dataRetFromReq 6.678 - receiverSlv->dataRetFromReq = semReq->msg; 6.679 + receiverSlv->dataRetFromReq = langReq->msg; 6.680 6.681 //bring both processors back from suspend 6.682 - resume_slaveVP( senderSlv, semEnv ); 6.683 - resume_slaveVP( receiverSlv, semEnv ); 6.684 + resume_slaveVP( senderSlv, langEnv ); 6.685 + resume_slaveVP( receiverSlv, langEnv ); 6.686 6.687 return; 6.688 } 6.689 @@ -782,21 +876,22 @@ 6.690 *Looks like can make single handler for both kinds of send.. 6.691 */ 6.692 //TODO: combine both send handlers into single handler 6.693 -inline void 6.694 -handleSendFromTo( VSsSemReq *semReq, VSsSemEnv *semEnv) 6.695 +//inline 6.696 +void 6.697 +handleSendFromTo( VSsLangReq *langReq, VSsLangEnv *langEnv) 6.698 { SlaveVP *senderSlv, *receiverSlv; 6.699 int32 *senderID, *receiverID; 6.700 int32 *key, keySz, receiverIDNumInt, senderIDNumInt; 6.701 - VSsSemReq *waitingReq; 6.702 + VSsLangReq *waitingReq; 6.703 HashEntry *entry; 6.704 - HashTable *commHashTbl = semEnv->commHashTbl; 6.705 + HashTable *commHashTbl = langEnv->commHashTbl; 6.706 6.707 DEBUG__printf2(dbgRqstHdlr,"SendFromTo req from task %d to %d", 6.708 - semReq->senderID[1],semReq->receiverID[1]) 6.709 + langReq->senderID[1],langReq->receiverID[1]) 6.710 6.711 - receiverID = semReq->receiverID; //For "send", know both send & recv procrs 6.712 - senderID = semReq->senderID; 6.713 - senderSlv = semReq->senderSlv; 6.714 + receiverID = langReq->receiverID; //For "send", know both send & recv procrs 6.715 + senderID = langReq->senderID; 6.716 + senderSlv = langReq->senderSlv; 6.717 6.718 6.719 receiverIDNumInt = receiverID[0] + 1; //include the count in the key 6.720 @@ -807,12 +902,12 @@ 6.721 memcpy( &key[1], receiverID, receiverIDNumInt * sizeof(int32) ); 6.722 memcpy( &key[1 + receiverIDNumInt], senderID, senderIDNumInt * sizeof(int32) ); 6.723 6.724 - entry = giveEntryElseInsertReqst32( key, semReq, commHashTbl ); 6.725 + entry = giveEntryElseInsertReqst32( key, langReq, commHashTbl ); 6.726 if( entry == NULL ) //was just inserted, means task has to wait 6.727 { return; 6.728 } 6.729 6.730 - waitingReq = (VSsSemReq *)entry->content; 6.731 + waitingReq = (VSsLangReq *)entry->content; 6.732 6.733 //At this point, know have waiting request(s) -- either sends or recv 6.734 if( waitingReq->reqType == send_from_to ) 6.735 @@ -822,12 +917,12 @@ 6.736 { //waiting request is a receive, so it completes pair with this send 6.737 #ifdef HOLISTIC__TURN_ON_OBSERVE_UCC 6.738 Dependency newD; 6.739 - newD.from_vp = sendPr->slaveID; 6.740 + newD.from_vp = sendPr->slaveNum; 6.741 newD.from_task = sendPr->numTimesAssignedToASlot; 6.742 - newD.to_vp = receivePr->slaveID; 6.743 + newD.to_vp = receivePr->slaveNum; 6.744 newD.to_task = receivePr->numTimesAssignedToASlot +1; 6.745 - //addToListOfArraysDependency(newD,semEnv->commDependenciesList); 6.746 - addToListOfArrays(Dependency,newD,semEnv->commDependenciesList); 6.747 + //addToListOfArraysDependency(newD,langEnv->commDependenciesList); 6.748 + addToListOfArrays(Dependency,newD,langEnv->commDependenciesList); 6.749 #endif 6.750 6.751 //set receiver slave, from the waiting request 6.752 @@ -846,11 +941,11 @@ 6.753 6.754 //attach msg that's in this send request to receiving procr 6.755 // when comes back from suspend, will have msg in dataRetFromReq 6.756 - receiverSlv->dataRetFromReq = semReq->msg; 6.757 + receiverSlv->dataRetFromReq = langReq->msg; 6.758 6.759 //bring both processors back from suspend 6.760 - resume_slaveVP( senderSlv, semEnv ); 6.761 - resume_slaveVP( receiverSlv, semEnv ); 6.762 + resume_slaveVP( senderSlv, langEnv ); 6.763 + resume_slaveVP( receiverSlv, langEnv ); 6.764 6.765 return; 6.766 } 6.767 @@ -862,19 +957,20 @@ 6.768 // 6.769 6.770 6.771 -inline void 6.772 -handleReceiveTypeTo( VSsSemReq *semReq, VSsSemEnv *semEnv) 6.773 +//inline 6.774 +void 6.775 +handleReceiveTypeTo( VSsLangReq *langReq, VSsLangEnv *langEnv) 6.776 { SlaveVP *senderSlv, *receiverSlv; 6.777 int32 *receiverID; 6.778 int32 *key, keySz, receiverIDNumInt; 6.779 - VSsSemReq *waitingReq; 6.780 + VSsLangReq *waitingReq; 6.781 HashEntry *entry; 6.782 - HashTable *commHashTbl = semEnv->commHashTbl; 6.783 + HashTable *commHashTbl = langEnv->commHashTbl; 6.784 6.785 - DEBUG__printf2(dbgRqstHdlr,"ReceiveType req to ID: %d type: %d",semReq->receiverID[1], semReq->msgType) 6.786 + DEBUG__printf2(dbgRqstHdlr,"ReceiveType req to ID: %d type: %d",langReq->receiverID[1], langReq->msgType) 6.787 6.788 - receiverID = semReq->receiverID; //For "send", know both send & recv procrs 6.789 - receiverSlv = semReq->receiverSlv; 6.790 + receiverID = langReq->receiverID; //For "send", know both send & recv procrs 6.791 + receiverSlv = langReq->receiverSlv; 6.792 6.793 6.794 //key is the receiverID plus the type -- have to copy them into key 6.795 @@ -883,14 +979,14 @@ 6.796 key = PR_PI__malloc( keySz ); 6.797 key[0] = receiverIDNumInt + 1; //loc 0 is num int32s in key 6.798 memcpy( &key[1], receiverID, receiverIDNumInt * sizeof(int32) ); 6.799 - key[ 1 + receiverIDNumInt ] = semReq->msgType; 6.800 + key[ 1 + receiverIDNumInt ] = langReq->msgType; 6.801 6.802 - entry = giveEntryElseInsertReqst32( key, semReq, commHashTbl );//clones 6.803 + entry = giveEntryElseInsertReqst32( key, langReq, commHashTbl );//clones 6.804 if( entry == NULL ) //was just inserted, means task has to wait 6.805 { return; 6.806 } 6.807 6.808 - waitingReq = (VSsSemReq *)entry->content; //previously cloned by insert 6.809 + waitingReq = (VSsLangReq *)entry->content; //previously cloned by insert 6.810 6.811 //At this point, know have waiting request(s) -- should be send(s) 6.812 if( waitingReq->reqType == send_type_to ) 6.813 @@ -914,30 +1010,30 @@ 6.814 6.815 #ifdef HOLISTIC__TURN_ON_OBSERVE_UCC 6.816 Dependency newD; 6.817 - newD.from_vp = sendPr->slaveID; 6.818 + newD.from_vp = sendPr->slaveNum; 6.819 newD.from_task = sendPr->numTimesAssignedToASlot; 6.820 - newD.to_vp = receivePr->slaveID; 6.821 + newD.to_vp = receivePr->slaveNum; 6.822 newD.to_task = receivePr->numTimesAssignedToASlot +1; 6.823 - //addToListOfArraysDependency(newD,semEnv->commDependenciesList); 6.824 - addToListOfArrays(Dependency,newD,semEnv->dynDependenciesList); 6.825 - int32 groupId = semReq->msgType; 6.826 - if(semEnv->ntonGroupsInfo->numInArray <= groupId){ 6.827 - makeHighestDynArrayIndexBeAtLeast(semEnv->ntonGroupsInfo, groupId); 6.828 + //addToListOfArraysDependency(newD,langEnv->commDependenciesList); 6.829 + addToListOfArrays(Dependency,newD,langEnv->dynDependenciesList); 6.830 + int32 groupId = langReq->msgType; 6.831 + if(langEnv->ntonGroupsInfo->numInArray <= groupId){ 6.832 + makeHighestDynArrayIndexBeAtLeast(langEnv->ntonGroupsInfo, groupId); 6.833 } 6.834 - if(semEnv->ntonGroups[groupId] == NULL){ 6.835 - semEnv->ntonGroups[groupId] = new_NtoN(groupId); 6.836 + if(langEnv->ntonGroups[groupId] == NULL){ 6.837 + langEnv->ntonGroups[groupId] = new_NtoN(groupId); 6.838 } 6.839 Unit u; 6.840 - u.vp = sendPr->slaveID; 6.841 + u.vp = sendPr->slaveNum; 6.842 u.task = sendPr->numTimesAssignedToASlot; 6.843 - addToListOfArrays(Unit,u,semEnv->ntonGroups[groupId]->senders); 6.844 - u.vp = receivePr->slaveID; 6.845 + addToListOfArrays(Unit,u,langEnv->ntonGroups[groupId]->senders); 6.846 + u.vp = receivePr->slaveNum; 6.847 u.task = receivePr->numTimesAssignedToASlot +1; 6.848 - addToListOfArrays(Unit,u,semEnv->ntonGroups[groupId]->receivers); 6.849 + addToListOfArrays(Unit,u,langEnv->ntonGroups[groupId]->receivers); 6.850 #endif 6.851 6.852 - resume_slaveVP( senderSlv, semEnv ); 6.853 - resume_slaveVP( receiverSlv, semEnv ); 6.854 + resume_slaveVP( senderSlv, langEnv ); 6.855 + resume_slaveVP( receiverSlv, langEnv ); 6.856 6.857 return; 6.858 } 6.859 @@ -947,20 +1043,21 @@ 6.860 6.861 /* 6.862 */ 6.863 -inline void 6.864 -handleReceiveFromTo( VSsSemReq *semReq, VSsSemEnv *semEnv) 6.865 +//inline 6.866 +void 6.867 +handleReceiveFromTo( VSsLangReq *langReq, VSsLangEnv *langEnv) 6.868 { SlaveVP *senderSlv, *receiverSlv; 6.869 int32 *senderID, *receiverID; 6.870 int32 *key, keySz, receiverIDNumInt, senderIDNumInt; 6.871 - VSsSemReq *waitingReq; 6.872 + VSsLangReq *waitingReq; 6.873 HashEntry *entry; 6.874 - HashTable *commHashTbl = semEnv->commHashTbl; 6.875 + HashTable *commHashTbl = langEnv->commHashTbl; 6.876 6.877 - DEBUG__printf2(dbgRqstHdlr,"RecFromTo req from ID: %d to ID: %d",semReq->senderID[1],semReq->receiverID[1]) 6.878 + DEBUG__printf2(dbgRqstHdlr,"RecFromTo req from ID: %d to ID: %d",langReq->senderID[1],langReq->receiverID[1]) 6.879 6.880 - receiverID = semReq->receiverID; //For "send", know both send & recv procrs 6.881 - senderID = semReq->senderID; 6.882 - receiverSlv = semReq->receiverSlv; 6.883 + receiverID = langReq->receiverID; //For "send", know both send & recv procrs 6.884 + senderID = langReq->senderID; 6.885 + receiverSlv = langReq->receiverSlv; 6.886 6.887 receiverIDNumInt = receiverID[0] + 1; //pos 0 doesn't include itself 6.888 senderIDNumInt = senderID[0] + 1; 6.889 @@ -970,24 +1067,24 @@ 6.890 memcpy( &key[1], receiverID, receiverIDNumInt * sizeof(int32) ); 6.891 memcpy( &key[1 + receiverIDNumInt], senderID, senderIDNumInt * sizeof(int32)); 6.892 6.893 - entry = giveEntryElseInsertReqst32( key, semReq, commHashTbl ); 6.894 + entry = giveEntryElseInsertReqst32( key, langReq, commHashTbl ); 6.895 if( entry == NULL ) //was just inserted, means task has to wait 6.896 { return; 6.897 } 6.898 6.899 - waitingReq = (VSsSemReq *)entry->content; 6.900 + waitingReq = (VSsLangReq *)entry->content; 6.901 6.902 //At this point, know have a request to rendez-vous -- should be send 6.903 if( waitingReq->reqType == send_from_to ) 6.904 { //waiting request is a send, so pair it with this receive 6.905 #ifdef HOLISTIC__TURN_ON_OBSERVE_UCC 6.906 Dependency newD; 6.907 - newD.from_vp = sendPr->slaveID; 6.908 + newD.from_vp = sendPr->slaveNum; 6.909 newD.from_task = sendPr->numTimesAssignedToASlot; 6.910 - newD.to_vp = receivePr->slaveID; 6.911 + newD.to_vp = receivePr->slaveNum; 6.912 newD.to_task = receivePr->numTimesAssignedToASlot +1; 6.913 - //addToListOfArraysDependency(newD,semEnv->commDependenciesList); 6.914 - addToListOfArrays(Dependency,newD,semEnv->commDependenciesList); 6.915 + //addToListOfArraysDependency(newD,langEnv->commDependenciesList); 6.916 + addToListOfArrays(Dependency,newD,langEnv->commDependenciesList); 6.917 #endif 6.918 6.919 //have receiver slave, now set sender slave 6.920 @@ -1005,8 +1102,8 @@ 6.921 //bring both processors back from suspend 6.922 PR_PI__free( waitingReq ); 6.923 6.924 - resume_slaveVP( senderSlv, semEnv ); 6.925 - resume_slaveVP( receiverSlv, semEnv ); 6.926 + resume_slaveVP( senderSlv, langEnv ); 6.927 + resume_slaveVP( receiverSlv, langEnv ); 6.928 6.929 return; 6.930 } 6.931 @@ -1017,18 +1114,19 @@ 6.932 /*Waits for all tasks that are direct children to end, then resumes calling 6.933 * task or thread 6.934 */ 6.935 -inline void 6.936 -handleTaskwait( VSsSemReq *semReq, SlaveVP *requestingSlv, VSsSemEnv *semEnv) 6.937 +//inline 6.938 +void 6.939 +handleTaskwait( VSsLangReq *langReq, SlaveVP *requestingSlv, VSsLangEnv *langEnv) 6.940 { VSsTaskStub* taskStub; 6.941 6.942 DEBUG__printf1(dbgRqstHdlr,"Taskwait request from processor %d", 6.943 - requestingSlv->slaveID) 6.944 + requestingSlv->slaveNum) 6.945 6.946 - taskStub = (VSsTaskStub *)PR_PI__give_lang_meta_task( requestingSlv, VSs_MAGIC_NUMBER); 6.947 + taskStub = (VSsTaskStub *)PR_PI__give_lang_meta_task_from_slave__ML( requestingSlv, VSs_MAGIC_NUMBER); 6.948 6.949 if( taskStub->numLiveChildTasks == 0 ) 6.950 { //nobody to wait for, resume 6.951 - resume_slaveVP( requestingSlv, semEnv ); 6.952 + resume_slaveVP( requestingSlv, langEnv ); 6.953 } 6.954 else //have to wait, mark waiting 6.955 { 6.956 @@ -1041,24 +1139,24 @@ 6.957 /* 6.958 */ 6.959 void 6.960 -handleMalloc( VSsSemReq *semReq, SlaveVP *requestingSlv, VSsSemEnv *semEnv ) 6.961 +handleMalloc( VSsLangReq *langReq, SlaveVP *requestingSlv, VSsLangEnv *langEnv ) 6.962 { void *ptr; 6.963 6.964 - DEBUG__printf1(dbgRqstHdlr,"Malloc request from processor %d",requestingSlv->slaveID) 6.965 + DEBUG__printf1(dbgRqstHdlr,"Malloc request from processor %d",requestingSlv->slaveNum) 6.966 6.967 - ptr = PR_PI__malloc( semReq->sizeToMalloc ); 6.968 + ptr = PR_PI__malloc( langReq->sizeToMalloc ); 6.969 requestingSlv->dataRetFromReq = ptr; 6.970 - resume_slaveVP( requestingSlv, semEnv ); 6.971 + resume_slaveVP( requestingSlv, langEnv ); 6.972 } 6.973 6.974 /* 6.975 */ 6.976 void 6.977 -handleFree( VSsSemReq *semReq, SlaveVP *requestingSlv, VSsSemEnv *semEnv ) 6.978 +handleFree( VSsLangReq *langReq, SlaveVP *requestingSlv, VSsLangEnv *langEnv ) 6.979 { 6.980 - DEBUG__printf1(dbgRqstHdlr,"Free request from processor %d",requestingSlv->slaveID) 6.981 - PR_PI__free( semReq->ptrToFree ); 6.982 - resume_slaveVP( requestingSlv, semEnv ); 6.983 + DEBUG__printf1(dbgRqstHdlr,"Free request from processor %d",requestingSlv->slaveNum) 6.984 + PR_PI__free( langReq->ptrToFree ); 6.985 + resume_slaveVP( requestingSlv, langEnv ); 6.986 } 6.987 6.988 6.989 @@ -1067,14 +1165,15 @@ 6.990 /*Uses ID as index into array of flags. If flag already set, resumes from 6.991 * end-label. Else, sets flag and resumes normally. 6.992 */ 6.993 -void inline 6.994 +void 6.995 +//inline 6.996 handleStartSingleton_helper( VSsSingleton *singleton, SlaveVP *reqstingSlv, 6.997 - VSsSemEnv *semEnv ) 6.998 + VSsLangEnv *langEnv ) 6.999 { 6.1000 if( singleton->hasFinished ) 6.1001 { //the code that sets the flag to true first sets the end instr addr 6.1002 reqstingSlv->dataRetFromReq = singleton->endInstrAddr; 6.1003 - resume_slaveVP( reqstingSlv, semEnv ); 6.1004 + resume_slaveVP( reqstingSlv, langEnv ); 6.1005 return; 6.1006 } 6.1007 else if( singleton->hasBeenStarted ) 6.1008 @@ -1086,42 +1185,45 @@ 6.1009 { //hasn't been started, so this is the first attempt at the singleton 6.1010 singleton->hasBeenStarted = TRUE; 6.1011 reqstingSlv->dataRetFromReq = 0x0; 6.1012 - resume_slaveVP( reqstingSlv, semEnv ); 6.1013 + resume_slaveVP( reqstingSlv, langEnv ); 6.1014 return; 6.1015 } 6.1016 } 6.1017 -void inline 6.1018 -handleStartFnSingleton( VSsSemReq *semReq, SlaveVP *requestingSlv, 6.1019 - VSsSemEnv *semEnv ) 6.1020 +void 6.1021 +//inline 6.1022 +handleStartFnSingleton( VSsLangReq *langReq, SlaveVP *requestingSlv, 6.1023 + VSsLangEnv *langEnv ) 6.1024 { VSsSingleton *singleton; 6.1025 - DEBUG__printf1(dbgRqstHdlr,"StartFnSingleton request from processor %d",requestingSlv->slaveID) 6.1026 + DEBUG__printf1(dbgRqstHdlr,"StartFnSingleton request from processor %d",requestingSlv->slaveNum) 6.1027 6.1028 - singleton = &(semEnv->fnSingletons[ semReq->singletonID ]); 6.1029 - handleStartSingleton_helper( singleton, requestingSlv, semEnv ); 6.1030 + singleton = &(langEnv->fnSingletons[ langReq->singletonID ]); 6.1031 + handleStartSingleton_helper( singleton, requestingSlv, langEnv ); 6.1032 } 6.1033 -void inline 6.1034 -handleStartDataSingleton( VSsSemReq *semReq, SlaveVP *requestingSlv, 6.1035 - VSsSemEnv *semEnv ) 6.1036 +void 6.1037 +//inline 6.1038 +handleStartDataSingleton( VSsLangReq *langReq, SlaveVP *requestingSlv, 6.1039 + VSsLangEnv *langEnv ) 6.1040 { VSsSingleton *singleton; 6.1041 6.1042 - DEBUG__printf1(dbgRqstHdlr,"StartDataSingleton request from processor %d",requestingSlv->slaveID) 6.1043 - if( *(semReq->singletonPtrAddr) == NULL ) 6.1044 + DEBUG__printf1(dbgRqstHdlr,"StartDataSingleton request from processor %d",requestingSlv->slaveNum) 6.1045 + if( *(langReq->singletonPtrAddr) == NULL ) 6.1046 { singleton = PR_PI__malloc( sizeof(VSsSingleton) ); 6.1047 singleton->waitQ = makePRQ(); 6.1048 singleton->endInstrAddr = 0x0; 6.1049 singleton->hasBeenStarted = FALSE; 6.1050 singleton->hasFinished = FALSE; 6.1051 - *(semReq->singletonPtrAddr) = singleton; 6.1052 + *(langReq->singletonPtrAddr) = singleton; 6.1053 } 6.1054 else 6.1055 - singleton = *(semReq->singletonPtrAddr); 6.1056 - handleStartSingleton_helper( singleton, requestingSlv, semEnv ); 6.1057 + singleton = *(langReq->singletonPtrAddr); 6.1058 + handleStartSingleton_helper( singleton, requestingSlv, langEnv ); 6.1059 } 6.1060 6.1061 6.1062 -void inline 6.1063 +void 6.1064 +//inline 6.1065 handleEndSingleton_helper( VSsSingleton *singleton, SlaveVP *requestingSlv, 6.1066 - VSsSemEnv *semEnv ) 6.1067 + VSsLangEnv *langEnv ) 6.1068 { PrivQueueStruc *waitQ; 6.1069 int32 numWaiting, i; 6.1070 SlaveVP *resumingSlv; 6.1071 @@ -1139,33 +1241,33 @@ 6.1072 { //they will resume inside start singleton, then jmp to end singleton 6.1073 resumingSlv = readPrivQ( waitQ ); 6.1074 resumingSlv->dataRetFromReq = singleton->endInstrAddr; 6.1075 - resume_slaveVP( resumingSlv, semEnv ); 6.1076 + resume_slaveVP( resumingSlv, langEnv ); 6.1077 } 6.1078 6.1079 - resume_slaveVP( requestingSlv, semEnv ); 6.1080 + resume_slaveVP( requestingSlv, langEnv ); 6.1081 6.1082 } 6.1083 -void inline 6.1084 -handleEndFnSingleton( VSsSemReq *semReq, SlaveVP *requestingSlv, 6.1085 - VSsSemEnv *semEnv ) 6.1086 +void 6.1087 +handleEndFnSingleton( VSsLangReq *langReq, SlaveVP *requestingSlv, 6.1088 + VSsLangEnv *langEnv ) 6.1089 { 6.1090 VSsSingleton *singleton; 6.1091 6.1092 - DEBUG__printf1(dbgRqstHdlr,"EndFnSingleton request from processor %d",requestingSlv->slaveID) 6.1093 + DEBUG__printf1(dbgRqstHdlr,"EndFnSingleton request from processor %d",requestingSlv->slaveNum) 6.1094 6.1095 - singleton = &(semEnv->fnSingletons[ semReq->singletonID ]); 6.1096 - handleEndSingleton_helper( singleton, requestingSlv, semEnv ); 6.1097 + singleton = &(langEnv->fnSingletons[ langReq->singletonID ]); 6.1098 + handleEndSingleton_helper( singleton, requestingSlv, langEnv ); 6.1099 } 6.1100 -void inline 6.1101 -handleEndDataSingleton( VSsSemReq *semReq, SlaveVP *requestingSlv, 6.1102 - VSsSemEnv *semEnv ) 6.1103 +void 6.1104 +handleEndDataSingleton( VSsLangReq *langReq, SlaveVP *requestingSlv, 6.1105 + VSsLangEnv *langEnv ) 6.1106 { 6.1107 VSsSingleton *singleton; 6.1108 6.1109 - DEBUG__printf1(dbgRqstHdlr,"EndDataSingleton request from processor %d",requestingSlv->slaveID) 6.1110 + DEBUG__printf1(dbgRqstHdlr,"EndDataSingleton request from processor %d",requestingSlv->slaveNum) 6.1111 6.1112 - singleton = *(semReq->singletonPtrAddr); 6.1113 - handleEndSingleton_helper( singleton, requestingSlv, semEnv ); 6.1114 + singleton = *(langReq->singletonPtrAddr); 6.1115 + handleEndSingleton_helper( singleton, requestingSlv, langEnv ); 6.1116 } 6.1117 6.1118 6.1119 @@ -1173,11 +1275,11 @@ 6.1120 * pointer out of the request and call it, then resume the VP. 6.1121 */ 6.1122 void 6.1123 -handleAtomic( VSsSemReq *semReq, SlaveVP *requestingSlv, VSsSemEnv *semEnv ) 6.1124 +handleAtomic( VSsLangReq *langReq, SlaveVP *requestingSlv, VSsLangEnv *langEnv ) 6.1125 { 6.1126 - DEBUG__printf1(dbgRqstHdlr,"Atomic request from processor %d",requestingSlv->slaveID) 6.1127 - semReq->fnToExecInMaster( semReq->dataForFn ); 6.1128 - resume_slaveVP( requestingSlv, semEnv ); 6.1129 + DEBUG__printf1(dbgRqstHdlr,"Atomic request from processor %d",requestingSlv->slaveNum) 6.1130 + langReq->fnToExecInMaster( langReq->dataForFn ); 6.1131 + resume_slaveVP( requestingSlv, langEnv ); 6.1132 } 6.1133 6.1134 /*First, it looks at the VP's semantic data, to see the highest transactionID 6.1135 @@ -1195,35 +1297,35 @@ 6.1136 *If NULL, then write requesting into the field and resume. 6.1137 */ 6.1138 void 6.1139 -handleTransStart( VSsSemReq *semReq, SlaveVP *requestingSlv, 6.1140 - VSsSemEnv *semEnv ) 6.1141 - { VSsSemData *semData; 6.1142 +handleTransStart( VSsLangReq *langReq, SlaveVP *requestingSlv, 6.1143 + VSsLangEnv *langEnv ) 6.1144 + { VSsLangData *langData; 6.1145 TransListElem *nextTransElem; 6.1146 6.1147 - DEBUG__printf1(dbgRqstHdlr,"TransStart request from processor %d",requestingSlv->slaveID) 6.1148 + DEBUG__printf1(dbgRqstHdlr,"TransStart request from processor %d",requestingSlv->slaveNum) 6.1149 6.1150 //check ordering of entering transactions is correct 6.1151 - semData = requestingSlv->semanticData; 6.1152 - if( semData->highestTransEntered > semReq->transID ) 6.1153 + langData = requestingSlv->langData; 6.1154 + if( langData->highestTransEntered > langReq->transID ) 6.1155 { //throw PR exception, which shuts down PR. 6.1156 PR_PI__throw_exception( "transID smaller than prev", requestingSlv, NULL); 6.1157 } 6.1158 //add this trans ID to the list of transactions entered -- check when 6.1159 // end a transaction 6.1160 - semData->highestTransEntered = semReq->transID; 6.1161 + langData->highestTransEntered = langReq->transID; 6.1162 nextTransElem = PR_PI__malloc( sizeof(TransListElem) ); 6.1163 - nextTransElem->transID = semReq->transID; 6.1164 - nextTransElem->nextTrans = semData->lastTransEntered; 6.1165 - semData->lastTransEntered = nextTransElem; 6.1166 + nextTransElem->transID = langReq->transID; 6.1167 + nextTransElem->nextTrans = langData->lastTransEntered; 6.1168 + langData->lastTransEntered = nextTransElem; 6.1169 6.1170 //get the structure for this transaction ID 6.1171 VSsTrans * 6.1172 - transStruc = &(semEnv->transactionStrucs[ semReq->transID ]); 6.1173 + transStruc = &(langEnv->transactionStrucs[ langReq->transID ]); 6.1174 6.1175 if( transStruc->VPCurrentlyExecuting == NULL ) 6.1176 { 6.1177 transStruc->VPCurrentlyExecuting = requestingSlv; 6.1178 - resume_slaveVP( requestingSlv, semEnv ); 6.1179 + resume_slaveVP( requestingSlv, langEnv ); 6.1180 } 6.1181 else 6.1182 { //note, might make future things cleaner if save request with VP and 6.1183 @@ -1248,15 +1350,15 @@ 6.1184 * resume both. 6.1185 */ 6.1186 void 6.1187 -handleTransEnd(VSsSemReq *semReq, SlaveVP *requestingSlv, VSsSemEnv *semEnv) 6.1188 - { VSsSemData *semData; 6.1189 +handleTransEnd(VSsLangReq *langReq, SlaveVP *requestingSlv, VSsLangEnv *langEnv) 6.1190 + { VSsLangData *langData; 6.1191 SlaveVP *waitingSlv; 6.1192 VSsTrans *transStruc; 6.1193 TransListElem *lastTrans; 6.1194 6.1195 - DEBUG__printf1(dbgRqstHdlr,"TransEnd request from processor %d",requestingSlv->slaveID) 6.1196 + DEBUG__printf1(dbgRqstHdlr,"TransEnd request from processor %d",requestingSlv->slaveNum) 6.1197 6.1198 - transStruc = &(semEnv->transactionStrucs[ semReq->transID ]); 6.1199 + transStruc = &(langEnv->transactionStrucs[ langReq->transID ]); 6.1200 6.1201 //make sure transaction ended in same VP as started it. 6.1202 if( transStruc->VPCurrentlyExecuting != requestingSlv ) 6.1203 @@ -1265,21 +1367,21 @@ 6.1204 } 6.1205 6.1206 //make sure nesting is correct -- last ID entered should == this ID 6.1207 - semData = requestingSlv->semanticData; 6.1208 - lastTrans = semData->lastTransEntered; 6.1209 - if( lastTrans->transID != semReq->transID ) 6.1210 + langData = requestingSlv->langData; 6.1211 + lastTrans = langData->lastTransEntered; 6.1212 + if( lastTrans->transID != langReq->transID ) 6.1213 { 6.1214 PR_PI__throw_exception( "trans incorrectly nested", requestingSlv, NULL ); 6.1215 } 6.1216 6.1217 - semData->lastTransEntered = semData->lastTransEntered->nextTrans; 6.1218 + langData->lastTransEntered = langData->lastTransEntered->nextTrans; 6.1219 6.1220 6.1221 waitingSlv = readPrivQ( transStruc->waitingVPQ ); 6.1222 transStruc->VPCurrentlyExecuting = waitingSlv; 6.1223 6.1224 if( waitingSlv != NULL ) 6.1225 - resume_slaveVP( waitingSlv, semEnv ); 6.1226 + resume_slaveVP( waitingSlv, langEnv ); 6.1227 6.1228 - resume_slaveVP( requestingSlv, semEnv ); 6.1229 + resume_slaveVP( requestingSlv, langEnv ); 6.1230 }
7.1 --- a/VSs_Request_Handlers.h Thu Oct 18 02:44:30 2012 -0700 7.2 +++ b/VSs_Request_Handlers.h Sat Jan 12 11:31:51 2013 -0800 7.3 @@ -1,5 +1,5 @@ 7.4 /* 7.5 - * Copyright 2009 OpenSourceStewardshipFoundation.org 7.6 + * Copyright 2009 OpenSourceResearchInstitute.org 7.7 * Licensed under GNU General Public License version 2 7.8 * 7.9 * Author: seanhalle@yahoo.com 7.10 @@ -14,46 +14,47 @@ 7.11 /*This header defines everything specific to the VSs semantic plug-in 7.12 */ 7.13 7.14 +inline 7.15 +void * 7.16 +handleSubmitTask( VSsLangReq *langReq, VSsLangEnv *langEnv); 7.17 inline void 7.18 -handleSubmitTask( VSsSemReq *semReq, VSsSemEnv *semEnv); 7.19 +handleEndTask( VSsLangReq *langReq, SlaveVP *requestingSlv, VSsLangEnv *langEnv ); 7.20 inline void 7.21 -handleEndTask( VSsSemReq *semReq, VSsSemEnv *semEnv); 7.22 +handleSendTypeTo( VSsLangReq *langReq, VSsLangEnv *langEnv); 7.23 inline void 7.24 -handleSendTypeTo( VSsSemReq *semReq, VSsSemEnv *semEnv); 7.25 +handleSendFromTo( VSsLangReq *langReq, VSsLangEnv *langEnv); 7.26 inline void 7.27 -handleSendFromTo( VSsSemReq *semReq, VSsSemEnv *semEnv); 7.28 +handleReceiveTypeTo( VSsLangReq *langReq, VSsLangEnv *langEnv); 7.29 inline void 7.30 -handleReceiveTypeTo( VSsSemReq *semReq, VSsSemEnv *semEnv); 7.31 +handleReceiveFromTo( VSsLangReq *langReq, VSsLangEnv *langEnv); 7.32 inline void 7.33 -handleReceiveFromTo( VSsSemReq *semReq, VSsSemEnv *semEnv); 7.34 -inline void 7.35 -handleTaskwait(VSsSemReq *semReq, SlaveVP *requestingSlv, VSsSemEnv *semEnv); 7.36 +handleTaskwait(VSsLangReq *langReq, SlaveVP *requestingSlv, VSsLangEnv *langEnv); 7.37 7.38 inline void 7.39 -handleMalloc( VSsSemReq *semReq, SlaveVP *requestingSlv, VSsSemEnv *semEnv); 7.40 +handleMalloc( VSsLangReq *langReq, SlaveVP *requestingSlv, VSsLangEnv *langEnv); 7.41 inline void 7.42 -handleFree( VSsSemReq *semReq, SlaveVP *requestingSlv, VSsSemEnv *semEnv ); 7.43 +handleFree( VSsLangReq *langReq, SlaveVP *requestingSlv, VSsLangEnv *langEnv ); 7.44 inline void 7.45 -handleTransEnd(VSsSemReq *semReq, SlaveVP *requestingSlv, VSsSemEnv*semEnv); 7.46 +handleTransEnd(VSsLangReq *langReq, SlaveVP *requestingSlv, VSsLangEnv*langEnv); 7.47 inline void 7.48 -handleTransStart( VSsSemReq *semReq, SlaveVP *requestingSlv, 7.49 - VSsSemEnv *semEnv ); 7.50 +handleTransStart( VSsLangReq *langReq, SlaveVP *requestingSlv, 7.51 + VSsLangEnv *langEnv ); 7.52 inline void 7.53 -handleAtomic( VSsSemReq *semReq, SlaveVP *requestingSlv, VSsSemEnv *semEnv); 7.54 +handleAtomic( VSsLangReq *langReq, SlaveVP *requestingSlv, VSsLangEnv *langEnv); 7.55 inline void 7.56 -handleStartFnSingleton( VSsSemReq *semReq, SlaveVP *reqstingSlv, 7.57 - VSsSemEnv *semEnv ); 7.58 +handleStartFnSingleton( VSsLangReq *langReq, SlaveVP *reqstingSlv, 7.59 + VSsLangEnv *langEnv ); 7.60 inline void 7.61 -handleEndFnSingleton( VSsSemReq *semReq, SlaveVP *requestingSlv, 7.62 - VSsSemEnv *semEnv ); 7.63 +handleEndFnSingleton( VSsLangReq *langReq, SlaveVP *requestingSlv, 7.64 + VSsLangEnv *langEnv ); 7.65 inline void 7.66 -handleStartDataSingleton( VSsSemReq *semReq, SlaveVP *reqstingSlv, 7.67 - VSsSemEnv *semEnv ); 7.68 +handleStartDataSingleton( VSsLangReq *langReq, SlaveVP *reqstingSlv, 7.69 + VSsLangEnv *langEnv ); 7.70 inline void 7.71 -handleEndDataSingleton( VSsSemReq *semReq, SlaveVP *requestingSlv, 7.72 - VSsSemEnv *semEnv ); 7.73 +handleEndDataSingleton( VSsLangReq *langReq, SlaveVP *requestingSlv, 7.74 + VSsLangEnv *langEnv ); 7.75 inline void 7.76 -free_task_stub( PRMetaTask *stubToFree ); 7.77 +free_task_stub( VSsTaskStub *stubToFree ); 7.78 7.79 7.80 #endif /* _VSs_REQ_H */
8.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000 8.2 +++ b/VSs_SS.c Sat Jan 12 11:31:51 2013 -0800 8.3 @@ -0,0 +1,268 @@ 8.4 +/* 8.5 + * Copyright 2010 OpenSourceCodeStewardshipFoundation 8.6 + * 8.7 + * Licensed under BSD 8.8 + */ 8.9 + 8.10 +#include <stdio.h> 8.11 +#include <stdlib.h> 8.12 +#include <malloc.h> 8.13 + 8.14 +#include "Queue_impl/PrivateQueue.h" 8.15 +#include "Hash_impl/PrivateHash.h" 8.16 + 8.17 +#include "VSs.h" 8.18 +#include "Measurement/VSs_Counter_Recording.h" 8.19 + 8.20 +//========================================================================== 8.21 + 8.22 + 8.23 + 8.24 +//=========================================================================== 8.25 + 8.26 +/* 8.27 + */ 8.28 +void 8.29 +VSs__start( SlaveVP *seedSlv ) 8.30 + { VSsLangEnv *langEnv; 8.31 + int32 i, coreNum, slotNum; 8.32 + VSsLangData *langData; 8.33 + VSsTaskStub *threadTaskStub, *parentTaskStub; 8.34 + 8.35 + langEnv = 8.36 + PR_SS__create_lang_env( sizeof(VSsLangEnv), seedSlv, VSs_MAGIC_NUMBER); 8.37 + 8.38 + //seed slave is a thread slave, so make a thread's task stub for it 8.39 + // and then make another to stand for the seed's parent task. Make 8.40 + // the parent be already ended, and have one child (the seed). This 8.41 + // will make the dissipate handler do the right thing when the seed 8.42 + // is dissipated. 8.43 + threadTaskStub = 8.44 + PR_int__create_lang_meta_task_in_slave__ML( sizeof(VSsTaskStub), seedSlv, VSs_MAGIC_NUMBER ); 8.45 + 8.46 + threadTaskStub->isEnded = FALSE; 8.47 + threadTaskStub->isWaitingForChildTasksToEnd = FALSE; 8.48 + 8.49 + parentTaskStub = 8.50 + PR_int__create_lang_meta_task__ML(sizeof(VSsTaskStub), seedSlv, VSs_MAGIC_NUMBER); 8.51 + 8.52 + parentTaskStub->isEnded = TRUE; 8.53 + parentTaskStub->numLiveChildThreads = 1; //so dissipate works for seed 8.54 + threadTaskStub->parentTaskStub = parentTaskStub; 8.55 + //Note: threadTaskStub and parentTaskStub freed when dissipate seedSlv 8.56 + 8.57 + //register the langlet's handlers with PR 8.58 +/* 8.59 + PR_SS__register_create_task_handler( &createTaskHandler, seedVP, VSs_MAGIC_NUMBER ); 8.60 + PR_SS__register_end_task_handler( &endTaskHandler, seedVP, VSs_MAGIC_NUMBER ); 8.61 + PR_SS__register_create_slave_handler( &createThreadHandler, seedVP, VSs_MAGIC_NUMBER ); 8.62 + PR_SS__register_dissipate_slave_handler( &endThreadHandler, seedVP, VSs_MAGIC_NUMBER ); 8.63 + RequestHandler createInitialLangDataFn; 8.64 + RequestHandler resetLangDataFn; 8.65 +*/ 8.66 + PR_SS__register_request_handler( &VSs__Request_Handler, seedSlv, VSs_MAGIC_NUMBER ); 8.67 + PR_SS__register_assigner( &VSs__assign_work_to_slot, seedSlv, VSs_MAGIC_NUMBER ); 8.68 + PR_SS__register_shutdown_handler( &VSs__shutdown, seedSlv, VSs_MAGIC_NUMBER ); 8.69 + 8.70 + #ifdef HOLISTIC__TURN_ON_PERF_COUNTERS 8.71 + _PRTopEnv->counterHandler = &VSs__counter_handler; 8.72 + VSs__init_counter_data_structs(); 8.73 + #endif 8.74 + 8.75 + 8.76 + //create the ready queues, hash tables used for matching and so forth 8.77 + langEnv->slavesReadyToResumeQ = makePRQ(); 8.78 + langEnv->taskReadyQ = makePRQ(); 8.79 + 8.80 + langEnv->argPtrHashTbl = makeHashTable32( 16, &PR_int__free ); 8.81 + langEnv->commHashTbl = makeHashTable32( 16, &PR_int__free ); 8.82 + 8.83 + langEnv->nextCoreToGetNewSlv = 0; 8.84 + 8.85 + 8.86 + //TODO: bug -- turn these arrays into dyn arrays to eliminate limit 8.87 + //langEnv->singletonHasBeenExecutedFlags = makeDynArrayInfo( ); 8.88 + //langEnv->transactionStrucs = makeDynArrayInfo( ); 8.89 + for( i = 0; i < NUM_STRUCS_IN_LANG_ENV; i++ ) 8.90 + { 8.91 + langEnv->fnSingletons[i].endInstrAddr = NULL; 8.92 + langEnv->fnSingletons[i].hasBeenStarted = FALSE; 8.93 + langEnv->fnSingletons[i].hasFinished = FALSE; 8.94 + langEnv->fnSingletons[i].waitQ = makePRQ(); 8.95 + langEnv->transactionStrucs[i].waitingVPQ = makePRQ(); 8.96 + } 8.97 + 8.98 + 8.99 + #ifdef HOLISTIC__TURN_ON_OBSERVE_UCC 8.100 + langEnv->unitList = makeListOfArrays(sizeof(Unit),128); 8.101 + langEnv->ctlDependenciesList = makeListOfArrays(sizeof(Dependency),128); 8.102 + langEnv->commDependenciesList = makeListOfArrays(sizeof(Dependency),128); 8.103 + langEnv->dynDependenciesList = makeListOfArrays(sizeof(Dependency),128); 8.104 + langEnv->ntonGroupsInfo = makePrivDynArrayOfSize((void***)&(langEnv->ntonGroups),8); 8.105 + 8.106 + langEnv->hwArcs = makeListOfArrays(sizeof(Dependency),128); 8.107 + memset(langEnv->last_in_slot,0,sizeof(NUM_CORES * NUM_ANIM_SLOTS * sizeof(Unit))); 8.108 + #endif 8.109 + } 8.110 + 8.111 + 8.112 +/*This shuts down the langket 8.113 + * Frees any memory allocated by VSs__init() and deletes any slaves or tasks 8.114 + * still in ready Qs. 8.115 + */ 8.116 +void 8.117 +VSs__shutdown( void *_langEnv ) 8.118 + { VSsLangEnv *langEnv = (VSsLangEnv *)_langEnv; 8.119 + 8.120 + #ifdef HOLISTIC__TURN_ON_OBSERVE_UCC 8.121 + //UCC 8.122 + FILE* output; 8.123 + int n; 8.124 + char filename[255]; 8.125 + for(n=0;n<255;n++) 8.126 + { 8.127 + sprintf(filename, "./counters/UCC.%d",n); 8.128 + output = fopen(filename,"r"); 8.129 + if(output) 8.130 + { 8.131 + fclose(output); 8.132 + }else{ 8.133 + break; 8.134 + } 8.135 + } 8.136 + if(n<255){ 8.137 + printf("Saving UCC to File: %s ...\n", filename); 8.138 + output = fopen(filename,"w+"); 8.139 + if(output!=NULL){ 8.140 + set_dependency_file(output); 8.141 + //fprintf(output,"digraph Dependencies {\n"); 8.142 + //set_dot_file(output); 8.143 + //FIXME: first line still depends on counters being enabled, replace w/ unit struct! 8.144 + //forAllInDynArrayDo(_PRTopEnv->counter_history_array_info, &print_dot_node_info ); 8.145 + forAllInListOfArraysDo(langEnv->unitList, &print_unit_to_file); 8.146 + forAllInListOfArraysDo( langEnv->commDependenciesList, &print_comm_dependency_to_file ); 8.147 + forAllInListOfArraysDo( langEnv->ctlDependenciesList, &print_ctl_dependency_to_file ); 8.148 + forAllInDynArrayDo(langEnv->ntonGroupsInfo,&print_nton_to_file); 8.149 + //fprintf(output,"}\n"); 8.150 + fflush(output); 8.151 + 8.152 + } else 8.153 + printf("Opening UCC file failed. Please check that folder \"counters\" exists in run directory and has write permission.\n"); 8.154 + } else { 8.155 + printf("Could not open UCC file, please clean \"counters\" folder. (Must contain less than 255 files.)\n"); 8.156 + } 8.157 + //Loop Graph 8.158 + for(n=0;n<255;n++) 8.159 + { 8.160 + sprintf(filename, "./counters/LoopGraph.%d",n); 8.161 + output = fopen(filename,"r"); 8.162 + if(output) 8.163 + { 8.164 + fclose(output); 8.165 + }else{ 8.166 + break; 8.167 + } 8.168 + } 8.169 + if(n<255){ 8.170 + printf("Saving LoopGraph to File: %s ...\n", filename); 8.171 + output = fopen(filename,"w+"); 8.172 + if(output!=NULL){ 8.173 + set_dependency_file(output); 8.174 + //fprintf(output,"digraph Dependencies {\n"); 8.175 + //set_dot_file(output); 8.176 + //FIXME: first line still depends on counters being enabled, replace w/ unit struct! 8.177 + //forAllInDynArrayDo(_PRTopEnv->counter_history_array_info, &print_dot_node_info ); 8.178 + forAllInListOfArraysDo( langEnv->unitList, &print_unit_to_file ); 8.179 + forAllInListOfArraysDo( langEnv->commDependenciesList, &print_comm_dependency_to_file ); 8.180 + forAllInListOfArraysDo( langEnv->ctlDependenciesList, &print_ctl_dependency_to_file ); 8.181 + forAllInListOfArraysDo( langEnv->dynDependenciesList, &print_dyn_dependency_to_file ); 8.182 + forAllInListOfArraysDo( langEnv->hwArcs, &print_hw_dependency_to_file ); 8.183 + //fprintf(output,"}\n"); 8.184 + fflush(output); 8.185 + 8.186 + } else 8.187 + printf("Opening LoopGraph file failed. Please check that folder \"counters\" exists in run directory and has write permission.\n"); 8.188 + } else { 8.189 + printf("Could not open LoopGraph file, please clean \"counters\" folder. (Must contain less than 255 files.)\n"); 8.190 + } 8.191 + 8.192 + 8.193 + freeListOfArrays(langEnv->unitList); 8.194 + freeListOfArrays(langEnv->commDependenciesList); 8.195 + freeListOfArrays(langEnv->ctlDependenciesList); 8.196 + freeListOfArrays(langEnv->dynDependenciesList); 8.197 + 8.198 + #endif 8.199 +#ifdef HOLISTIC__TURN_ON_PERF_COUNTERS 8.200 + for(n=0;n<255;n++) 8.201 + { 8.202 + sprintf(filename, "./counters/Counters.%d.csv",n); 8.203 + output = fopen(filename,"r"); 8.204 + if(output) 8.205 + { 8.206 + fclose(output); 8.207 + }else{ 8.208 + break; 8.209 + } 8.210 + } 8.211 + if(n<255){ 8.212 + printf("Saving Counter measurements to File: %s ...\n", filename); 8.213 + output = fopen(filename,"w+"); 8.214 + if(output!=NULL){ 8.215 + set_counter_file(output); 8.216 + int i; 8.217 + for(i=0;i<NUM_CORES;i++){ 8.218 + forAllInListOfArraysDo( langEnv->counterList[i], &print_counter_events_to_file ); 8.219 + fflush(output); 8.220 + } 8.221 + 8.222 + } else 8.223 + printf("Opening UCC file failed. Please check that folder \"counters\" exists in run directory and has write permission.\n"); 8.224 + } else { 8.225 + printf("Could not open UCC file, please clean \"counters\" folder. (Must contain less than 255 files.)\n"); 8.226 + } 8.227 + 8.228 +#endif 8.229 + 8.230 + //Things to free: 8.231 + // tasks and slaves in ready Qs 8.232 + // ready Qs 8.233 + // tasks and slaves in the comm hash table 8.234 + // comm hash table 8.235 + // tasks in the argPtrHashTbl 8.236 + // the argPtrHashTbl 8.237 + PrivQueueStruc *queue; 8.238 + SlaveVP *slave; 8.239 + VSsTaskStub *task; 8.240 + 8.241 + queue = langEnv->slavesReadyToResumeQ; 8.242 + slave = readPrivQ( queue ); 8.243 + while( slave != NULL ) 8.244 + { handleShutdownDissipate(slave); 8.245 + PR_int__recycle_slave__ML( slave ); //recycler is for all of PR 8.246 + slave = readPrivQ( queue ); 8.247 + } 8.248 + freePrivQ( queue ); 8.249 + 8.250 + queue = langEnv->taskReadyQ; 8.251 + task = readPrivQ( queue ); 8.252 + while( task != NULL ) 8.253 + { handleFreeTask( task ); 8.254 + task = readPrivQ( queue ); 8.255 + } 8.256 + freePrivQ( queue ); 8.257 + 8.258 + freeHashTable( langEnv->commHashTbl ); 8.259 + freeHashTable( langEnv->argPtrHashTbl ); 8.260 + 8.261 + int32 i; 8.262 + for( i = 0; i < NUM_STRUCS_IN_LANG_ENV; i++ ) 8.263 + { 8.264 + freePrivQ( langEnv->fnSingletons[i].waitQ ); 8.265 + freePrivQ( langEnv->transactionStrucs[i].waitingVPQ ); 8.266 + } 8.267 + 8.268 + PR_int__free_lang_env( langEnv ); 8.269 + } 8.270 + 8.271 +