# HG changeset patch # User Sean Halle # Date 1360124665 28800 # Node ID 91caa8a9d59187b7eb9ad895d7da031fb9b932b3 # Parent 3b30da4643d1796a11a8693a8d611d92fe64d8b9 Back to compile process, fixing compile errors diff -r 3b30da4643d1 -r 91caa8a9d591 VSs.c --- a/VSs.c Sat Jan 12 11:31:51 2013 -0800 +++ b/VSs.c Tue Feb 05 20:24:25 2013 -0800 @@ -161,7 +161,7 @@ reqData.fnPtr = fnPtr; reqData.initData = initData; - PR_WL__send_create_slaveVP_req( &reqData, thdID, &handleCreateThd, + PR_WL__send_create_slaveVP_req( &reqData, thdID, (CreateHandler)&handleCreateThd, creatingThd, VSs_MAGIC_NUMBER ); return (SlaveVP *)creatingThd->dataRetFromReq; } @@ -177,7 +177,8 @@ VSs__end_thread( SlaveVP *thdToEnd ) { //the lang request is null for VSs version of end slave - PR_WL__send_end_slave_req( NULL, &handleDissipate, thdToEnd, VSs_MAGIC_NUMBER ); + PR_WL__send_end_slave_req( NULL, (RequestHandler)&handleDissipate, thdToEnd, + VSs_MAGIC_NUMBER ); } @@ -258,7 +259,8 @@ reqData.reqType = taskwait; reqData.callingSlv = animSlv; - PR_WL__send_lang_request( &reqData, &handleTaskwait, animSlv, VSs_MAGIC_NUMBER ); + PR_WL__send_lang_request( &reqData, (RequestHandler)&handleTaskwait, animSlv, + VSs_MAGIC_NUMBER ); } @@ -266,7 +268,8 @@ //========================== send and receive ============================ // -inline int32 * +inline +int32 * VSs__give_self_taskID( SlaveVP *animSlv ) { return PR__give_ID_from_slave( animSlv, VSs_MAGIC_NUMBER ); @@ -288,7 +291,8 @@ reqData.nextReqInHashEntry = NULL; - PR_WL__send_lang_request( &reqData, &handleSendTypeTo, senderSlv, VSs_MAGIC_NUMBER ); + PR_WL__send_lang_request( &reqData, (RequestHandler)&handleSendTypeTo, + senderSlv, VSs_MAGIC_NUMBER ); //When come back from suspend, no longer own data reachable from msg } @@ -306,7 +310,8 @@ reqData.nextReqInHashEntry = NULL; - PR_WL__send_lang_request( &reqData, &handleSendFromTo, senderSlv, VSs_MAGIC_NUMBER ); + PR_WL__send_lang_request( &reqData, (RequestHandler)&handleSendFromTo, + senderSlv, VSs_MAGIC_NUMBER ); } @@ -331,7 +336,8 @@ reqData.nextReqInHashEntry = NULL; - PR_WL__send_lang_request( &reqData, &handleReceiveTypeTo, receiverSlv, VSs_MAGIC_NUMBER ); + PR_WL__send_lang_request( &reqData, (RequestHandler)&handleReceiveTypeTo, + receiverSlv, VSs_MAGIC_NUMBER ); return receiverSlv->dataRetFromReq; } @@ -356,7 +362,8 @@ reqData.nextReqInHashEntry = NULL; DEBUG__printf2(dbgRqstHdlr,"WL: receive from %d to: %d", reqData.senderID[1], reqData.receiverID[1]); - PR_WL__send_lang_request( &reqData, &handleReceiveFromTo, receiverSlv, VSs_MAGIC_NUMBER ); + PR_WL__send_lang_request( &reqData, (RequestHandler)&handleReceiveFromTo, + receiverSlv, VSs_MAGIC_NUMBER ); return receiverSlv->dataRetFromReq; } @@ -392,11 +399,12 @@ reqData.reqType = singleton_fn_start; reqData.singletonID = singletonID; - PR_WL__send_lang_request( &reqData, &handleStartFnSingleton, animSlv, VSs_MAGIC_NUMBER ); + PR_WL__send_lang_request( &reqData, (RequestHandler)&handleStartFnSingleton, + animSlv, VSs_MAGIC_NUMBER ); if( animSlv->dataRetFromReq ) //will be 0 or addr of label in end singleton { VSsLangEnv *langEnv = - PR_int__give_lang_env_for_slave__ML( animSlv, VSs_MAGIC_NUMBER ); + PR_int__give_lang_env_for_slave( animSlv, VSs_MAGIC_NUMBER ); asm_write_ret_from_singleton(&(langEnv->fnSingletons[ singletonID])); } } @@ -416,7 +424,8 @@ reqData.reqType = singleton_data_start; reqData.singletonPtrAddr = singletonAddr; - PR_WL__send_lang_request( &reqData, &handleStartDataSingleton, animSlv, VSs_MAGIC_NUMBER ); + PR_WL__send_lang_request( &reqData, (RequestHandler)&handleStartDataSingleton, + animSlv, VSs_MAGIC_NUMBER ); if( animSlv->dataRetFromReq ) //either 0 or end singleton's return addr { //Assembly code changes the return addr on the stack to the one // saved into the singleton by the end-singleton-fn @@ -442,14 +451,15 @@ //don't need this addr until after at least one singleton has reached // this function VSsLangEnv * - langEnv = PR_int__give_lang_env_for_slave__ML( animSlv, VSs_MAGIC_NUMBER ); + langEnv = PR_int__give_lang_env_for_slave( animSlv, VSs_MAGIC_NUMBER ); asm_write_ret_from_singleton(&(langEnv->fnSingletons[ singletonID])); reqData.reqType = singleton_fn_end; reqData.singletonID = singletonID; - PR_WL__send_lang_request( &reqData, &handleEndFnSingleton, animSlv, VSs_MAGIC_NUMBER ); + PR_WL__send_lang_request( &reqData, (RequestHandler)&handleEndFnSingleton, + animSlv, VSs_MAGIC_NUMBER ); EndSingletonInstrAddr: return; @@ -471,7 +481,8 @@ reqData.reqType = singleton_data_end; reqData.singletonPtrAddr = singletonPtrAddr; - PR_WL__send_lang_request( &reqData, &handleEndDataSingleton, animSlv, VSs_MAGIC_NUMBER ); + PR_WL__send_lang_request( &reqData, (RequestHandler)&handleEndDataSingleton, + animSlv, VSs_MAGIC_NUMBER ); } /*This executes the function in the masterVP, so it executes in isolation @@ -495,7 +506,8 @@ reqData.fnToExecInMaster = ptrToFnToExecInMaster; reqData.dataForFn = data; - PR_WL__send_lang_request( &reqData, &handleAtomic, animSlv, VSs_MAGIC_NUMBER ); + PR_WL__send_lang_request( &reqData, (RequestHandler)&handleAtomic, + animSlv, VSs_MAGIC_NUMBER ); } @@ -522,7 +534,8 @@ reqData.reqType = trans_start; reqData.transID = transactionID; - PR_WL__send_lang_request( &reqData, &handleTransStart, animSlv, VSs_MAGIC_NUMBER ); + PR_WL__send_lang_request( &reqData, (RequestHandler)&handleTransStart, + animSlv, VSs_MAGIC_NUMBER ); } /*This suspends to the master, then uses transactionID as index into an @@ -544,7 +557,8 @@ reqData.reqType = trans_end; reqData.transID = transactionID; - PR_WL__send_lang_request( &reqData, &handleTransEnd, animSlv, VSs_MAGIC_NUMBER ); + PR_WL__send_lang_request( &reqData, (RequestHandler)&handleTransEnd, + animSlv, VSs_MAGIC_NUMBER ); } //======================== Internal ================================== diff -r 3b30da4643d1 -r 91caa8a9d591 VSs.h --- a/VSs.h Sat Jan 12 11:31:51 2013 -0800 +++ b/VSs.h Tue Feb 05 20:24:25 2013 -0800 @@ -366,13 +366,8 @@ SlaveVP *creatingSlv, int32 coreToAssignOnto); //===================== ===================== -inline -void * -handleSubmitTask( VSsLangReq *langReq, VSsLangEnv *langEnv ); -inline -void -handleEndTask( VSsLangReq *langReq, SlaveVP *requestingSlv, VSsLangEnv *langEnv ); +#include "VSs_Request_Handlers.h" //===================== Measurement of Lang Overheads ===================== #include "Measurement/VSs_Measurement.h" diff -r 3b30da4643d1 -r 91caa8a9d591 VSs_PluginFns.c --- a/VSs_PluginFns.c Sat Jan 12 11:31:51 2013 -0800 +++ b/VSs_PluginFns.c Tue Feb 05 20:24:25 2013 -0800 @@ -13,7 +13,7 @@ //=========================== Local Fn Prototypes =========================== void -resume_slaveVP( SlaveVP *slave, VSsLangEnv *langEnv ); +VSs__resume_slave( SlaveVP *slave, VSsLangEnv *langEnv ); inline void handleLangReq( PRReqst *req, SlaveVP *requestingSlv, VSsLangEnv *langEnv ); @@ -51,12 +51,11 @@ * to suspend both kinds, but also to keep explicit slave stacks clean from * the junk tasks are allowed to leave behind. */ -SlaveVP * +void VSs__assign_work_to_slot( void *_langEnv, AnimSlot *slot ) { SlaveVP *returnSlv; VSsLangEnv *langEnv; int32 coreNum, slotNum; - PRMetaTask *returnMetaTask = NULL; VSsTaskStub *newTaskStub; coreNum = slot->coreSlotIsOn; @@ -68,19 +67,26 @@ returnSlv = readPrivQ( langEnv->slavesReadyToResumeQ ); if( returnSlv != NULL ) //Yes, have a slave, so return it. { returnSlv->coreAnimatedBy = coreNum; - //returnMetaTask = returnSlv->metaTask; - fixme; //use PR_int__put_slave_into_slot( SlaveVP *slave, AnimSlot *slot ) - goto ReturnTheMetaTask; + + fixme; //check that putting into slot and call chain are correct + PR_int__put_slave_into_slot( returnSlv, slot ); + goto Success; } + //No ready slaves, so check for ready tasks newTaskStub = readPrivQ( langEnv->taskReadyQ ); if( newTaskStub != NULL ) - { //returnMetaTask = newTaskStub->protoMetaTask; - fixme; //use PR_int__put_task_into_slot( SlaveVP *slave, AnimSlot *slot ) - goto ReturnTheMetaTask; + { + fixme; //check that putting into slot and call chain are correct + PR_int__put_task_into_slot( newTaskStub, slot ); + goto Success; } + + //If here, didn't assign any work + Fail: + fixme; //figure out what to do -- go through holistic code still? -ReturnTheMetaTask: //doing gotos to here should help with holistic.. + Success: //doing gotos to here should help with holistic.. #ifdef HOLISTIC__TURN_ON_OBSERVE_UCC //This no longer works -- should be moved into PR in master @@ -105,7 +111,7 @@ newD.to_task = returnSlv->numTimesAssignedToASlot; addToListOfArrays(Dependency, newD, langEnv->ctlDependenciesList); } - returnMetaTask = returnSlv->metaTask; + returnMetaTask = returnSlv->metaTasks; } else //returnSlv != NULL { //assignSlv->numTimesAssigned++; @@ -125,72 +131,24 @@ prev_in_slot; } #endif +/* PR handles work available in lang env and in process.. if( isEmptyPrivQ(langEnv->slavesReadyToResumeQ) && isEmptyPrivQ(langEnv->taskReadyQ) ) PR_int__clear_work_in_lang_env(langEnv); - - return( returnMetaTask ); + */ + + return; } -//=========================== Request Handler ============================ -// -/* - * (Not inline because invoked indirectly via a pointer) - */ - -void -handleLangReq( void *_langReq, SlaveVP *reqSlv, VSsLangEnv *langEnv ) - { VSsLangReq *langReq; - - langReq = (VSsLangReq *)_langReq; - if( langReq == NULL ) return; - - switch( langReq->reqType ) //lang handlers are all in other file - { - case send_type_to: handleSendTypeTo( langReq, langEnv); - break; - case send_from_to: handleSendFromTo( langReq, langEnv); - break; - case receive_type_to: handleReceiveTypeTo(langReq, langEnv); - break; - case receive_from_to: handleReceiveFromTo(langReq, langEnv); - break; - case taskwait: handleTaskwait( langReq, reqSlv, langEnv); - break; - - //==================================================================== - case malloc_req: handleMalloc( langReq, reqSlv, langEnv); - break; - case free_req: handleFree( langReq, reqSlv, langEnv); - break; - case singleton_fn_start: handleStartFnSingleton(langReq, reqSlv, langEnv); - break; - case singleton_fn_end: handleEndFnSingleton( langReq, reqSlv, langEnv); - break; - case singleton_data_start:handleStartDataSingleton(langReq,reqSlv,langEnv); - break; - case singleton_data_end: handleEndDataSingleton(langReq, reqSlv, langEnv); - break; - case atomic: handleAtomic( langReq, reqSlv, langEnv); - break; - case trans_start: handleTransStart( langReq, reqSlv, langEnv); - break; - case trans_end: handleTransEnd( langReq, reqSlv, langEnv); - break; - } - } - - - //=========================== Helper ============================== void -resume_slaveVP( SlaveVP *slave, VSsLangEnv *langEnv ) +VSs__resume_slave( SlaveVP *slave, VSsLangEnv *langEnv ) { //both suspended tasks and suspended explicit slaves resumed with this writePrivQ( slave, langEnv->slavesReadyToResumeQ ); - PR_int__set_work_in_lang_env(langEnv); +//PR handles this.. PR_int__set_work_in_lang_env(langEnv); #ifdef HOLISTIC__TURN_ON_PERF_COUNTERS /* diff -r 3b30da4643d1 -r 91caa8a9d591 VSs_Request_Handlers.c --- a/VSs_Request_Handlers.c Sat Jan 12 11:31:51 2013 -0800 +++ b/VSs_Request_Handlers.c Tue Feb 05 20:24:25 2013 -0800 @@ -18,7 +18,7 @@ //=========================== Local Fn Prototypes =========================== void -resume_slaveVP( SlaveVP *slave, VSsLangEnv *langEnv ); +VSs__resume_slave( SlaveVP *slave, VSsLangEnv *langEnv ); @@ -90,8 +90,8 @@ VSsTaskStub* newStub; //Create a new task stub, with enough room at end to copy args there - newStub = (VSsTaskStub *)PR_int__create_lang_meta_task__ML( - sizeof(VSsTaskStub) + taskType->sizeOfArgs, VSs_MAGIC_NUMBER ); + newStub = (VSsTaskStub *)PR_int__create_lang_meta_task( + sizeof(VSsTaskStub) + taskType->sizeOfArgs, &VSs__lang_meta_task_freer, VSs_MAGIC_NUMBER ); newStub->numBlockingProp = taskType->numCtldArgs; newStub->taskType = taskType; @@ -112,13 +112,24 @@ return newStub; } +void +VSs__lang_meta_task_freer( void *_langMetaTask ) + { //no malloc'd structs inside task stub, so nothing to do + } + +void * +VSs__create_empty_lang_meta_task_in_slave( SlaveVP *slave ) + { + return (void *)VSs__create_generic_slave_task_stub_in_slave( slave ); + } + VSsTaskStub * VSs__create_generic_slave_task_stub_in_slave( SlaveVP *slave ) { VSsTaskStub *newStub; - newStub = (VSsTaskStub *)PR_int__create_lang_meta_task_in_slave__ML( - sizeof(VSsTaskStub), slave, VSs_MAGIC_NUMBER ); + newStub = (VSsTaskStub *)PR_int__create_lang_meta_task_in_slave( + sizeof(VSsTaskStub), &VSs__lang_meta_task_freer, slave, VSs_MAGIC_NUMBER ); newStub->numBlockingProp = 0; newStub->taskType = NULL; newStub->ptrEntries = NULL; @@ -130,6 +141,30 @@ return newStub; } +/*Initialize semantic data struct.. this initializer doesn't need any input, + * but some languages may need something from inside the request that was sent + * to create a slave.. in that case, just make initializer do the malloc then + * use the PR_PI__give_lang_data inside the create handler, and fill in the + * langData values there. + */ +void * +VSs__create_lang_data_in_slave( SlaveVP *slave ) + { VSsLangData *langData; + + + langData = PR_PI__create_lang_data_in_slave( sizeof(VSsLangData), + &VSs__langDataFreer, slave, VSs_MAGIC_NUMBER ); + + langData->highestTransEntered = -1; + langData->lastTransEntered = NULL; + return langData; + } + +void +VSs__langDataFreer( void *_langData ) + { //no extra structs have been malloc'd into the lang data, so nothing to do + } + inline VSsTaskStubCarrier * create_task_carrier( VSsTaskStub *taskStub, int32 argNum, int32 rdOrWrite ) @@ -168,7 +203,9 @@ langReq = (VSsLangReq *) _langReq; langEnv = (VSsLangEnv *) _langEnv; - newSlv = PR_int__create_slave( langReq->fnPtr, langReq->initData ); + newSlv = PR_PI__create_slave( langReq->fnPtr, langReq->initData ); + + VSs__create_lang_data_in_slave( newSlv ); parentTaskStub = PR_PI__give_lang_meta_task_from_slave__ML( requestingSlv, VSs_MAGIC_NUMBER ); parentTaskStub->numLiveChildThreads += 1; @@ -217,35 +254,19 @@ //For VSs, caller needs ptr to created thread returned to it requestingSlv->dataRetFromReq = newSlv; - resume_slaveVP(requestingSlv , langEnv ); - resume_slaveVP( newSlv, langEnv ); + PR_PI__make_slave_ready(requestingSlv , langEnv ); + PR_PI__make_slave_ready( newSlv, langEnv ); return newSlv; } -/*Initialize semantic data struct.. this initializer doesn't need any input, - * but some languages may need something from inside the request that was sent - * to create a slave.. in that case, just make initializer do the malloc then - * use the PR_PI__give_lang_data inside the create handler, and fill in the - * langData values there. - */ -void * -createInitialSemanticData( ) - { VSsLangData *langData; - - langData = PR_PI__malloc( sizeof(VSsLangData) ); - - langData->highestTransEntered = -1; - langData->lastTransEntered = NULL; - return langData; - } /*SlaveVP dissipate -- this is NOT task-end!, only call this to end explicitly * created threads */ //inline void -handleDissipate( SlaveVP *requestingSlv, VSsLangEnv *langEnv ) +handleDissipate( void *langReq, SlaveVP *requestingSlv, VSsLangEnv *langEnv ) { VSsTaskStub *parentTaskStub, *ownTaskStub; @@ -271,7 +292,7 @@ if( parentTaskStub->isWaitingForChildTasksToEnd ) return; //still waiting on tasks (should be impossible) else //parent free to resume - resume_slaveVP( PR_PI__give_slave_lang_meta_task_assigned_to(parentTaskStub), langEnv ); + PR_PI__make_slave_ready( PR_PI__give_slave_lang_meta_task_is_assigned_to(parentTaskStub), langEnv ); } //check if this is last child of ended parent (note, not possible to @@ -286,6 +307,7 @@ //PR frees the langData, task stub and requesting slave's base state return; } + inline void handleShutdownDissipate( SlaveVP *requestingSlv, VSsLangEnv *langEnv ) @@ -308,9 +330,14 @@ void freeVSsLangData( void *_langData ) { // + fixme; //check -- PR should handle freeing the lang data itself. + //this should only free stuff malloc'd into the langData PR_PI__free( _langData ); } +/*Will be used by a landData recycler, when (and if) such a thing added + to PR + */ void resetVSsLangData( void *_langData ) { VSsLangData *langData = (VSsLangData *)_langData; @@ -479,8 +506,8 @@ * the hash-entry's count of enabled and non-finished readers.*/ taskStub->numBlockingProp -= 1; if( taskStub->numBlockingProp == 0 ) - { writePrivQ( taskStub, langEnv->taskReadyQ ); - PR_int__set_work_in_lang_env( langEnv ); + { PR_PI__make_task_ready( taskStub, langEnv ); + //PR_int__set_work_in_lang_env( langEnv ); } ptrEntry->numEnabledNonDoneReaders += 1; } @@ -503,8 +530,8 @@ * into the readyQ.*/ taskStub->numBlockingProp -= 1; if( taskStub->numBlockingProp == 0 ) - { writePrivQ( taskStub, langEnv->taskReadyQ ); - PR_int__set_work_in_lang_env( langEnv ); + { PR_PI__make_task_ready( taskStub, langEnv ); + //PR_int__set_work_in_lang_env( langEnv ); } ptrEntry->hasEnabledNonFinishedWriter = TRUE; } @@ -517,7 +544,7 @@ } //for argNum //resume the parent, creator - resume_slaveVP( langReq->callingSlv, langEnv ); + PR_PI__make_slave_ready( langReq->callingSlv, langEnv ); return taskStub; } @@ -569,7 +596,7 @@ VSsPointerEntry **ptrEntries; endingTaskStub = - (VSsTaskStub *)PR_int__give_lang_meta_task_from_slave__ML( requestingSlv, VSs_MAGIC_NUMBER ); + (VSsTaskStub *)PR_int__give_lang_meta_task_from_slave( requestingSlv, VSs_MAGIC_NUMBER ); args = endingTaskStub->args; endingTaskType = endingTaskStub->taskType; @@ -584,7 +611,7 @@ parentStub->numLiveChildTasks == 0) { parentStub->isWaitingForChildTasksToEnd = FALSE; - resume_slaveVP( PR_PI__give_slave_lang_meta_task_assigned_to(parentStub), langEnv ); + PR_PI__make_slave_ready( PR_PI__give_slave_lang_meta_task_is_assigned_to(parentStub), langEnv ); } //Check if parent ended, and this was last descendent, then free it @@ -628,8 +655,8 @@ // task-stub into the readyQ. waitingTaskStub->numBlockingProp -= 1; if( waitingTaskStub->numBlockingProp == 0 ) - { writePrivQ( waitingTaskStub, langEnv->taskReadyQ ); - PR_int__set_work_in_lang_env( langEnv ); + { PR_PI__make_task_ready( waitingTaskStub, langEnv ); + //PR_int__set_work_in_lang_env( langEnv ); } } } @@ -653,8 +680,8 @@ // If it becomes zero, then put the task-stub into the readyQ. waitingTaskStub->numBlockingProp -= 1; if( waitingTaskStub->numBlockingProp == 0 ) - { writePrivQ( waitingTaskStub, langEnv->taskReadyQ ); - PR_int__set_work_in_lang_env( langEnv ); + { PR_PI__make_task_ready( waitingTaskStub, langEnv ); + //PR_int__set_work_in_lang_env( langEnv ); } } else @@ -670,8 +697,8 @@ // into the readyQ. waitingTaskStub->numBlockingProp -= 1; if( waitingTaskStub->numBlockingProp == 0 ) - { writePrivQ( waitingTaskStub, langEnv->taskReadyQ ); - PR_int__set_work_in_lang_env( langEnv ); + { PR_PI__make_task_ready( waitingTaskStub, langEnv ); + //PR_int__set_work_in_lang_env( langEnv ); } //Get next waiting task waitingTaskCarrier = peekPrivQ( ptrEntry->waitersQ ); @@ -772,7 +799,7 @@ */ //inline void -handleSendTypeTo( VSsLangReq *langReq, VSsLangEnv *langEnv ) +handleSendTypeTo( VSsLangReq *langReq, SlaveVP *reqSlave, VSsLangEnv *langEnv ) { SlaveVP *senderSlv, *receiverSlv; int32 *senderID, *receiverID; int32 *key, keySz, receiverIDNumInt; @@ -780,6 +807,8 @@ HashEntry *entry; HashTable *commHashTbl = langEnv->commHashTbl; + //Note, don't use reqSlave, but need it to match RequestHandler signature + receiverID = langReq->receiverID; //For "send", know both send & recv procrs senderSlv = langReq->senderSlv; @@ -860,8 +889,8 @@ receiverSlv->dataRetFromReq = langReq->msg; //bring both processors back from suspend - resume_slaveVP( senderSlv, langEnv ); - resume_slaveVP( receiverSlv, langEnv ); + PR_PI__make_slave_ready( senderSlv, langEnv ); + PR_PI__make_slave_ready( receiverSlv, langEnv ); return; } @@ -878,7 +907,7 @@ //TODO: combine both send handlers into single handler //inline void -handleSendFromTo( VSsLangReq *langReq, VSsLangEnv *langEnv) +handleSendFromTo( VSsLangReq *langReq, SlaveVP *dummySlave, VSsLangEnv *langEnv) { SlaveVP *senderSlv, *receiverSlv; int32 *senderID, *receiverID; int32 *key, keySz, receiverIDNumInt, senderIDNumInt; @@ -944,8 +973,8 @@ receiverSlv->dataRetFromReq = langReq->msg; //bring both processors back from suspend - resume_slaveVP( senderSlv, langEnv ); - resume_slaveVP( receiverSlv, langEnv ); + PR_PI__make_slave_ready( senderSlv, langEnv ); + PR_PI__make_slave_ready( receiverSlv, langEnv ); return; } @@ -959,7 +988,7 @@ //inline void -handleReceiveTypeTo( VSsLangReq *langReq, VSsLangEnv *langEnv) +handleReceiveTypeTo( VSsLangReq *langReq, SlaveVP *dummySlv, VSsLangEnv *langEnv) { SlaveVP *senderSlv, *receiverSlv; int32 *receiverID; int32 *key, keySz, receiverIDNumInt; @@ -1032,8 +1061,8 @@ addToListOfArrays(Unit,u,langEnv->ntonGroups[groupId]->receivers); #endif - resume_slaveVP( senderSlv, langEnv ); - resume_slaveVP( receiverSlv, langEnv ); + PR_PI__make_slave_ready( senderSlv, langEnv ); + PR_PI__make_slave_ready( receiverSlv, langEnv ); return; } @@ -1045,7 +1074,7 @@ */ //inline void -handleReceiveFromTo( VSsLangReq *langReq, VSsLangEnv *langEnv) +handleReceiveFromTo( VSsLangReq *langReq, SlaveVP *dummySlv, VSsLangEnv *langEnv) { SlaveVP *senderSlv, *receiverSlv; int32 *senderID, *receiverID; int32 *key, keySz, receiverIDNumInt, senderIDNumInt; @@ -1102,8 +1131,8 @@ //bring both processors back from suspend PR_PI__free( waitingReq ); - resume_slaveVP( senderSlv, langEnv ); - resume_slaveVP( receiverSlv, langEnv ); + PR_PI__make_slave_ready( senderSlv, langEnv ); + PR_PI__make_slave_ready( receiverSlv, langEnv ); return; } @@ -1126,7 +1155,7 @@ if( taskStub->numLiveChildTasks == 0 ) { //nobody to wait for, resume - resume_slaveVP( requestingSlv, langEnv ); + PR_PI__make_slave_ready( requestingSlv, langEnv ); } else //have to wait, mark waiting { @@ -1146,7 +1175,7 @@ ptr = PR_PI__malloc( langReq->sizeToMalloc ); requestingSlv->dataRetFromReq = ptr; - resume_slaveVP( requestingSlv, langEnv ); + PR_PI__make_slave_ready( requestingSlv, langEnv ); } /* @@ -1156,7 +1185,7 @@ { DEBUG__printf1(dbgRqstHdlr,"Free request from processor %d",requestingSlv->slaveNum) PR_PI__free( langReq->ptrToFree ); - resume_slaveVP( requestingSlv, langEnv ); + PR_PI__make_slave_ready( requestingSlv, langEnv ); } @@ -1173,7 +1202,7 @@ if( singleton->hasFinished ) { //the code that sets the flag to true first sets the end instr addr reqstingSlv->dataRetFromReq = singleton->endInstrAddr; - resume_slaveVP( reqstingSlv, langEnv ); + PR_PI__make_slave_ready( reqstingSlv, langEnv ); return; } else if( singleton->hasBeenStarted ) @@ -1185,7 +1214,7 @@ { //hasn't been started, so this is the first attempt at the singleton singleton->hasBeenStarted = TRUE; reqstingSlv->dataRetFromReq = 0x0; - resume_slaveVP( reqstingSlv, langEnv ); + PR_PI__make_slave_ready( reqstingSlv, langEnv ); return; } } @@ -1241,10 +1270,10 @@ { //they will resume inside start singleton, then jmp to end singleton resumingSlv = readPrivQ( waitQ ); resumingSlv->dataRetFromReq = singleton->endInstrAddr; - resume_slaveVP( resumingSlv, langEnv ); + PR_PI__make_slave_ready( resumingSlv, langEnv ); } - resume_slaveVP( requestingSlv, langEnv ); + PR_PI__make_slave_ready( requestingSlv, langEnv ); } void @@ -1279,7 +1308,7 @@ { DEBUG__printf1(dbgRqstHdlr,"Atomic request from processor %d",requestingSlv->slaveNum) langReq->fnToExecInMaster( langReq->dataForFn ); - resume_slaveVP( requestingSlv, langEnv ); + PR_PI__make_slave_ready( requestingSlv, langEnv ); } /*First, it looks at the VP's semantic data, to see the highest transactionID @@ -1325,7 +1354,7 @@ if( transStruc->VPCurrentlyExecuting == NULL ) { transStruc->VPCurrentlyExecuting = requestingSlv; - resume_slaveVP( requestingSlv, langEnv ); + PR_PI__make_slave_ready( requestingSlv, langEnv ); } else { //note, might make future things cleaner if save request with VP and @@ -1381,7 +1410,15 @@ transStruc->VPCurrentlyExecuting = waitingSlv; if( waitingSlv != NULL ) - resume_slaveVP( waitingSlv, langEnv ); + PR_PI__make_slave_ready( waitingSlv, langEnv ); - resume_slaveVP( requestingSlv, langEnv ); + PR_PI__make_slave_ready( requestingSlv, langEnv ); } + +void +VSs__make_task_ready( void *taskStub, void *_langEnv ) + { + writePrivQ( taskStub, ((VSsLangEnv*)_langEnv)->taskReadyQ ); + } + + diff -r 3b30da4643d1 -r 91caa8a9d591 VSs_Request_Handlers.h --- a/VSs_Request_Handlers.h Sat Jan 12 11:31:51 2013 -0800 +++ b/VSs_Request_Handlers.h Tue Feb 05 20:24:25 2013 -0800 @@ -14,19 +14,25 @@ /*This header defines everything specific to the VSs semantic plug-in */ +SlaveVP * +handleCreateThd( void *_langReq, SlaveVP *requestingSlv, void *_langEnv ); +void +handleDissipate( void *langReq, SlaveVP *requestingSlv, VSsLangEnv *langEnv ); + inline void * handleSubmitTask( VSsLangReq *langReq, VSsLangEnv *langEnv); inline void handleEndTask( VSsLangReq *langReq, SlaveVP *requestingSlv, VSsLangEnv *langEnv ); + inline void -handleSendTypeTo( VSsLangReq *langReq, VSsLangEnv *langEnv); +handleSendTypeTo( VSsLangReq *langReq, SlaveVP *dummySlv, VSsLangEnv *langEnv); inline void -handleSendFromTo( VSsLangReq *langReq, VSsLangEnv *langEnv); +handleSendFromTo( VSsLangReq *langReq, SlaveVP* dummySlv, VSsLangEnv *langEnv); inline void -handleReceiveTypeTo( VSsLangReq *langReq, VSsLangEnv *langEnv); +handleReceiveTypeTo( VSsLangReq *langReq, SlaveVP *dummySlv, VSsLangEnv *langEnv); inline void -handleReceiveFromTo( VSsLangReq *langReq, VSsLangEnv *langEnv); +handleReceiveFromTo( VSsLangReq *langReq, SlaveVP *dummySlv, VSsLangEnv *langEnv); inline void handleTaskwait(VSsLangReq *langReq, SlaveVP *requestingSlv, VSsLangEnv *langEnv); diff -r 3b30da4643d1 -r 91caa8a9d591 VSs_SS.c --- a/VSs_SS.c Sat Jan 12 11:31:51 2013 -0800 +++ b/VSs_SS.c Tue Feb 05 20:24:25 2013 -0800 @@ -38,13 +38,13 @@ // will make the dissipate handler do the right thing when the seed // is dissipated. threadTaskStub = - PR_int__create_lang_meta_task_in_slave__ML( sizeof(VSsTaskStub), seedSlv, VSs_MAGIC_NUMBER ); + PR_int__create_lang_meta_task_in_slave( sizeof(VSsTaskStub), &VSs__lang_meta_task_freer, seedSlv, VSs_MAGIC_NUMBER ); threadTaskStub->isEnded = FALSE; threadTaskStub->isWaitingForChildTasksToEnd = FALSE; parentTaskStub = - PR_int__create_lang_meta_task__ML(sizeof(VSsTaskStub), seedSlv, VSs_MAGIC_NUMBER); + PR_int__create_lang_meta_task(sizeof(VSsTaskStub), &VSs__lang_meta_task_freer, seedSlv, VSs_MAGIC_NUMBER); parentTaskStub->isEnded = TRUE; parentTaskStub->numLiveChildThreads = 1; //so dissipate works for seed @@ -52,6 +52,12 @@ //Note: threadTaskStub and parentTaskStub freed when dissipate seedSlv //register the langlet's handlers with PR + PR_SS__register_assigner( &VSs__assign_work_to_slot, seedSlv, VSs_MAGIC_NUMBER ); + PR_SS__register_shutdown_handler( &VSs__handle_shutdown, seedSlv, VSs_MAGIC_NUMBER ); + PR_SS__register_lang_data_creator( &VSs__create_lang_data_in_slave, seedSlv, VSs_MAGIC_NUMBER ); + PR_SS__register_lang_meta_task_creator( &VSs__create_empty_lang_meta_task_in_slave, seedSlv, VSs_MAGIC_NUMBER ); + PR_SS__register_make_slave_ready_fn( &VSs__resume_slave ); + PR_SS__register_make_task_ready_fn( &VSs__make_task_ready ); /* PR_SS__register_create_task_handler( &createTaskHandler, seedVP, VSs_MAGIC_NUMBER ); PR_SS__register_end_task_handler( &endTaskHandler, seedVP, VSs_MAGIC_NUMBER ); @@ -59,10 +65,8 @@ PR_SS__register_dissipate_slave_handler( &endThreadHandler, seedVP, VSs_MAGIC_NUMBER ); RequestHandler createInitialLangDataFn; RequestHandler resetLangDataFn; -*/ PR_SS__register_request_handler( &VSs__Request_Handler, seedSlv, VSs_MAGIC_NUMBER ); - PR_SS__register_assigner( &VSs__assign_work_to_slot, seedSlv, VSs_MAGIC_NUMBER ); - PR_SS__register_shutdown_handler( &VSs__shutdown, seedSlv, VSs_MAGIC_NUMBER ); + */ #ifdef HOLISTIC__TURN_ON_PERF_COUNTERS _PRTopEnv->counterHandler = &VSs__counter_handler; @@ -106,12 +110,12 @@ } -/*This shuts down the langket +/*This shuts down the langlet * Frees any memory allocated by VSs__init() and deletes any slaves or tasks * still in ready Qs. */ void -VSs__shutdown( void *_langEnv ) +VSs__handle_shutdown( void *_langEnv ) { VSsLangEnv *langEnv = (VSsLangEnv *)_langEnv; #ifdef HOLISTIC__TURN_ON_OBSERVE_UCC @@ -235,15 +239,17 @@ SlaveVP *slave; VSsTaskStub *task; + //dissipate any slaves still in the readyQ queue = langEnv->slavesReadyToResumeQ; slave = readPrivQ( queue ); while( slave != NULL ) - { handleShutdownDissipate(slave); - PR_int__recycle_slave__ML( slave ); //recycler is for all of PR + { handleShutdownDissipate( slave ); + PR_int__recycle_slave( slave ); //recycler is for all of PR slave = readPrivQ( queue ); } freePrivQ( queue ); + //end any tasks still in the readyQ queue = langEnv->taskReadyQ; task = readPrivQ( queue ); while( task != NULL )