VMS/VMS_Implementations/VMS_impls/VMS__MC_shared_impl: AnimationMaster.c comparison

comparison AnimationMaster.c @ 267:608833ae2c5d

Checkpoint -- about to clean up AnimationMaster, deleting a bunch of stuff

author	Sean Halle <seanhalle@yahoo.com>
date	Sun, 04 Nov 2012 18:39:28 -0800
parents	a5fa1e087c7e
children	e5bd470b562b

comparison

equal deleted inserted replaced

-:cfb14d4ffc6d
+:d13c619ea73b
 #include "PR.h"
 #include "VSs_impl/VSs.h"
 inline void
-replaceWithNewSlotSlv( SlaveVP *requestingSlv, PRProcessEnv *processEnv );
+replaceWithNewSlotSlv( SlaveVP *slave );
 /*The animationMaster embodies most of the animator of the language.  The
 * animator is what emodies the behavior of language constructs.
 * As such, it is the animationMaster, in combination with the plugin
 //Check if newly-done slave in slot, which will need request handled
 if( currSlot->workIsDone )
 {
 currSlot->workIsDone         = FALSE;
-currSlot->needsSlaveAssigned = TRUE;
+currSlot->needsWorkAssigned = TRUE;
 HOLISTIC__Record_AppResponder_start;
 MEAS__startReqHdlr;
 currSlot->workIsDone         = FALSE;
-currSlot->needsSlaveAssigned = TRUE;
+currSlot->needsWorkAssigned = TRUE;
 SlaveVP *currSlave = currSlot->slaveAssignedToSlot;
 	justAddedReqHdlrChg();
 			//handle the request, either by PR or by the language
 if( currSlave->requests->reqType != LangReq )
 HOLISTIC__Record_AppResponder_end;
 MEAS__endReqHdlr;
 }
 //If slot empty, hand to Assigner to fill with a slave
-if( currSlot->needsSlaveAssigned )
+if( currSlot->needsWorkAssigned )
 {    //Call plugin's Assigner to give slot a new slave
 HOLISTIC__Record_Assigner_start;
 assignedSlaveVP =
 (*slaveAssigner)( semanticEnv, currSlot );
 //put the chosen slave into slot, and adjust flags and state
 if( assignedSlaveVP != NULL )
 { currSlot->slaveAssignedToSlot = assignedSlaveVP;
 assignedSlaveVP->animSlotAssignedTo       = currSlot;
-currSlot->needsSlaveAssigned  = FALSE;
+currSlot->needsWorkAssigned  = FALSE;
 numSlotsFilled               += 1;
 HOLISTIC__Record_Assigner_end;
 }
 }
 int32           thisCoresIdx;
 //#ifdef  MODE__MULTI_LANG
 SlaveVP        *slave;
 PRProcess      *process;
-PRConstrEnvHolder *constrEnvHolder;
 int32           langMagicNumber;
 //#endif
 //======================== Initializations ========================
 masterEnv        = (MasterEnv*)_PRTopEnv;
 //process the request made by the slave (held inside slave struc)
 slave = currSlot->slaveAssignedToSlot;
 //check if the completed work was a task..
-if( slave->taskMetaInfo->isATask )
+if( slave->metaTask->isATask )
 {
-if( slave->reqst->type == TaskEnd )
+if( slave->request->type == TaskEnd )
 {    //do task end handler, which is registered separately
 //note, end hdlr may use semantic data from reqst..
 //#ifdef  MODE__MULTI_LANG
 //get end-task handler
 //taskEndHandler = lookup( slave->reqst->langMagicNumber, processEnv );
-taskEndHandler = slave->taskMetaInfo->endTaskHandler;
+taskEndHandler = slave->metaTask->endTaskHandler;
 //#endif
 (*taskEndHandler)( slave, semanticEnv );
 goto AssignWork;
 }
 goto AssignWork;
 }
 } //if has suspended slave that needs handling
 //if slot empty, hand to Assigner to fill with a slave
-if( currSlot->needsSlaveAssigned )
+if( currSlot->needsWorkAssigned )
 {    //Call plugin's Assigner to give slot a new slave
 HOLISTIC__Record_Assigner_start;
 AssignWork:
 //put the chosen slave into slot, and adjust flags and state
 if( assignedSlaveVP != NULL )
 { currSlot->slaveAssignedToSlot = assignedSlaveVP;
 assignedSlaveVP->animSlotAssignedTo = currSlot;
-currSlot->needsSlaveAssigned  = FALSE;
+currSlot->needsWorkAssigned  = FALSE;
 numSlotsFilled               += 1;
 }
 else
 {
-currSlot->needsSlaveAssigned  = TRUE; //local write
+currSlot->needsWorkAssigned  = TRUE; //local write
 }
 HOLISTIC__Record_Assigner_end;
 }//if slot needs slave assigned
 }//for( slotIdx..
 int32           thisCoresIdx;
 //#ifdef  MODE__MULTI_LANG
 SlaveVP        *slave;
 PRProcess      *process;
-PRConstrEnvHolder *constrEnvHolder;
 int32           langMagicNumber;
 //#endif
 //======================== Initializations ========================
 masterEnv        = (MasterEnv*)_PRTopEnv;
 goto AssignWork;
 }
 } //if has suspended slave that needs handling
 //if slot empty, hand to Assigner to fill with a slave
-if( currSlot->needsSlaveAssigned )
+if( currSlot->needsWorkAssigned )
 {    //Call plugin's Assigner to give slot a new slave
 HOLISTIC__Record_Assigner_start;
 AssignWork:
 //put the chosen slave into slot, and adjust flags and state
 if( assignedSlaveVP != NULL )
 { currSlot->slaveAssignedToSlot = assignedSlaveVP;
 assignedSlaveVP->animSlotAssignedTo = currSlot;
-currSlot->needsSlaveAssigned  = FALSE;
+currSlot->needsWorkAssigned  = FALSE;
 numSlotsFilled               += 1;
 }
 else
 {
-currSlot->needsSlaveAssigned  = TRUE; //local write
+currSlot->needsWorkAssigned  = TRUE; //local write
 }
 HOLISTIC__Record_Assigner_end;
 }//if slot needs slave assigned
 }//for( slotIdx..
 //#ifdef MODE__MULTI_LANG
 //#ifdef MODE__MULTI_PROCESS
 void animationMaster( void *initData, SlaveVP *masterVP )
 {
 int32           slotIdx;
-//   int32           numSlotsFilled;
 AnimSlot       *currSlot;
 //Used while scanning and filling animation slots
 AnimSlot      **animSlots;
 //Local copies, for performance
 }
 }
 #endif  //MODE__MULTI_LANG
 #endif  //MODE__MULTI_PROCESS
+//This version of the master selects one of three loops, depending upon
+// whether stand-alone single language (just slaves), or standalone with
+// tasks, or multi-lang (implies multi-process)
+void animationMaster( void *initData, SlaveVP *masterVP )
+{
+int32           slotIdx;
+AnimSlot       *currSlot;
+//Used while scanning and filling animation slots
+AnimSlot      **animSlots;
+//Local copies, for performance
+MasterEnv      *masterEnv;
+int32           thisCoresIdx;
+//======================== Initializations ========================
+masterEnv        = (MasterEnv*)_PRTopEnv;
+thisCoresIdx     = masterVP->coreAnimatedBy;
+animSlots        = masterEnv->allAnimSlots[thisCoresIdx];
+HOLISTIC__Insert_Master_Global_Vars;
+//======================== animationMaster ========================
+//Have three different modes, and the master behavior is different for
+// each, so jump to the loop that corresponds to the mode.
+//
+switch(mode)
+{ case StandaloneSlavesOnly:
+while(1)
+{       MEAS__Capture_Pre_Master_Point
+for( slotIdx = 0; slotIdx < NUM_ANIM_SLOTS; slotIdx++)
+{
+currSlot = animSlots[ slotIdx ];
+masterFunction_StandaloneSlavesOnly( currSlot );
+}
+MEAS__Capture_Post_Master_Point;
+masterSwitchToCoreCtlr( masterVP ); //returns when ctlr switches back to master
+flushRegisters();
+}
+case StandaloneWTasks:
+while(1)
+{       MEAS__Capture_Pre_Master_Point
+for( slotIdx = 0; slotIdx < NUM_ANIM_SLOTS; slotIdx++)
+{
+currSlot = animSlots[ slotIdx ];
+masterFunction_StandaloneWTasks( currSlot );
+}
+MEAS__Capture_Post_Master_Point;
+masterSwitchToCoreCtlr( masterVP ); //returns when ctlr switches back to master
+flushRegisters();
+}
+case MultiLang:
+while(1)
+{       MEAS__Capture_Pre_Master_Point
+for( slotIdx = 0; slotIdx < NUM_ANIM_SLOTS; slotIdx++)
+{
+currSlot = animSlots[ slotIdx ];
+masterFunction_multiLang( currSlot );
+}
+MEAS__Capture_Post_Master_Point;
+masterSwitchToCoreCtlr( masterVP ); //returns when ctlr switches back to master
+flushRegisters();
+}
+}
+}
 inline
 void
 masterFunction_multiLang( AnimSlot  *currSlot )
 {    //Scan the animation slots
 int32           magicNumber;
 RequestHandler  requestHandler;
 //Check if newly-done slave in slot, which will need request handled
 if( currSlot->workIsDone )
 { currSlot->workIsDone = FALSE;
+currSlot->needsWorkAssigned = TRUE;
 HOLISTIC__Record_AppResponder_start; //TODO: update to check which process for each slot
 MEAS__startReqHdlr;
 //process the request made by the slave (held inside slave struc)
 slave = currSlot->slaveAssignedToSlot;
+req = slave->request;
-//check if the slave was doing a task..
-//Action depends on both on the request type, and whether it's on
+//If the requesting slave is a slot slave, and request is not
-// a generic slave vs a suspended task
+// task-end, then turn it into a free task slave.
-if( slave->metaTask->taskType == AtomicTask ||
+if( slave->typeOfVP == SlotTaskSlv && req->reqType != TaskEnd )
-slave->metaTask->taskType == SuspendedTask )
+replaceWithNewSlotSlv( slave );
-{
-switch( slave->request->reqType )
+//Handle task create and end first -- they're special cases..
-{ case TaskEnd:
+switch( req->reqType )
-{ PRHandle_EndTask( slave ); //if free task slave, update count, put into recycle Q -- do handler before lang's handler
+{ case TaskEnd:
+{ //do PR handler, which calls lang's hdlr and does recycle of
-//do task end handler, which is registered separately
+// free task slave if needed -- PR handler checks for free task Slv
-//note, end hdlr may use semantic data from reqst..
+PRHandle_EndTask( slave );                               break;
-//get end-task handler
-RequestHandler
-taskEndHandler = slave->request->handler;
-semanticEnv = PR_int__give_sem_env_for_slave( slave,
-slave->request->langMagicNumber );
-(*taskEndHandler)( slave, semanticEnv );
-goto AssignWork;
-}
-case TaskCreate:
-{ PRHandle_CreateTask( slave );
-RequestHandler
-taskCreateHandler = slave->request->handler;
-semanticEnv = PR_int__give_sem_env_for_slave( slave,
-slave->request->langMagicNumber );
-(*taskCreateHandler)( slave, semanticEnv ); //resumes creating slave
-goto AssignWork;
-}
-default:
-{    //is a task, and just suspended, so tied to a free task slave
-//First turn slot slave into free task slave & make replacement
-if( slave->typeOfVP == SlotTaskSlv )
-replaceWithNewSlotSlv( slave, slave->processSlaveIsIn->processEnv );
-//goto normal slave request handling
-goto SlaveReqHandling;
-}
 }
-}
+case TaskCreate:
-else //is a slave that suspended
+{ //Do PR's create-task handler, which calls the lang's hdlr
-{
+// PR handler checks for free task Slv
+PRHandle_CreateTask( slave );                            break;
-SlaveReqHandling:
-//Q: put the switch in inline call, to clean up code?
-req = slave->request;
-switch( req->reqType )
-{ case SlvCreate:    PRHandle_CreateSlave( slave );    break;
-case SlvDissipate: PRHandle_Dissipate( slave ); break;
-case Service:      PR_int__handle_PRServiceReq( slave );  break; //resume into PR's own semantic env
-case Hardware: //for future expansion
-case IO:       //for future expansion
-case OSCall:   //for future expansion
-case Language: //normal sem request
-magicNumber = slave->request->langMagicNumber;
-semanticEnv = PR_PI__give_sem_env_for( slave, magicNumber );
-requestHandler = semanticEnv->requestHdlr;
-(*requestHandler)( slave, semanticEnv ); //(note: indirect Fn call more efficient when use fewer params, instead re-fetch from slave)
 }
+case SlvCreate:    PRHandle_CreateSlave( slave );           break;
-HOLISTIC__Record_AppResponder_end;
+case SlvDissipate: PRHandle_Dissipate( slave );             break;
-MEAS__endReqHdlr;
+case Service:      PR_int__handle_PRServiceReq( slave );    break; //resume into PR's own semantic env
+case Hardware: //for future expansion
-goto AssignWork;
+case IO:       //for future expansion
-}
+case OSCall:   //for future expansion
-} //if has suspended slave that needs handling
+PR_int__throw_exception("Not implemented");             break;
+case Language: //normal sem request
+magicNumber = req->langMagicNumber;
+semanticEnv = PR_PI__give_sem_env_for( slave, magicNumber );
+requestHandler = semanticEnv->requestHdlr;
+(*requestHandler)( req->semReq, slave, semanticEnv );
+}
+HOLISTIC__Record_AppResponder_end;
+MEAS__endReqHdlr;
+} //if have request to be handled
-//End up here when the slot did not have ended work in it (no req)
+if( currSlot->needsWorkAssigned )
-//So, here, if slot empty, look for work to fill the slot
+{
-if( currSlot->needsSlaveAssigned )
+HOLISTIC__Record_Assigner_start;
-{       HOLISTIC__Record_Assigner_start;
-AssignWork:
 //Scan sem environs, looking for semEnv with ready work.
 // call the Assigner for that sem Env, to get a slave for the slot
 assignedSlaveVP = assignWork( semanticEnv, currSlot );
-//put the chosen slave into slot, and adjust flags and state
+//if work found, put into slot, and adjust flags and state
 if( assignedSlaveVP != NULL )
 { currSlot->slaveAssignedToSlot = assignedSlaveVP;
 assignedSlaveVP->animSlotAssignedTo = currSlot;
-currSlot->needsSlaveAssigned  = FALSE;
+currSlot->needsWorkAssigned  = FALSE;
-}
-else
-{ currSlot->needsSlaveAssigned  = TRUE; //local write
 }
 HOLISTIC__Record_Assigner_end;
 }//if slot needs slave assigned
 }
 */
 inline void
 replaceWithNewSlotSlv( SlaveVP *requestingSlv, PRProcess *process )
 { SlaveVP *newSlotSlv;
+When slot slave converted to a free task slave, insert the process pointer -- slot slaves are not assigned to any process;
+when convert from slot slave to free task slave, check what should do about num (live slaves + live tasks) inside VSs's task stub, and properly update process's count of liveFreeTaskSlaves
 //get a new slave to be the slot slave
 newSlotSlv     = readPrivQ( process->freeTaskSlvRecycleQ );
 if( newSlotSlv == NULL )
 { newSlotSlv  = PR_int__create_slaveVP( &idle_fn, NULL, process, 0);
 //just made a new free task slave, so count it
 }
 //set slave values to make it the slot slave
 newSlotSlv->metaTask              = NULL;
 newSlotSlv->typeOfVP              = SlotTaskSlv;
-newSlotSlv->needsTaskAssigned     = TRUE;
+//   newSlotSlv->needsTaskAssigned     = TRUE;
 //a slot slave is pinned to a particular slot on a particular core
 //Note, this happens before the request is seen by handler, so nothing
 // has had a chance to change the coreAnimatedBy or anything else..
 newSlotSlv->animSlotAssignedTo = requestingSlv->animSlotAssignedTo;
 process->slotTaskSlvs[coreNum][slotNum] = newSlotSlv;
 //Fix up requester, to be an extra slave now (but not an ended one)
 // because it's active, doesn't go into freeTaskSlvRecycleQ
 requestingSlv->typeOfVP = FreeTaskSlv;
-check_if_need_to_change_metaTask_type_or_something;
+requestingSlv->metaTask->taskType = FreeTask;
 }
 /*This does:
 *  but am making it possible.
 */
 inline SlaveVP *
 assignWork( PRProcess *process, AnimSlot *slot )
 { SlaveVP        *returnSlv;
-//VSsSemEnv      *semEnv;
-//VSsSemData     *semData;
 int32           coreNum, slotNum;
-PRMetaTask     *newMetaTask, *assignedMetaTask;
+PRMetaTask     *assignedMetaTask;
-SlaveVP        *freeTaskSlv;
 coreNum = slot->coreSlotIsOn;
-if( _PRTopEnv->overrideAssigner != NULL )
+if( process->overrideAssigner != NULL )
-{ assignedMetaTask = (*_PRTopEnv->overrideAssigner)( process, slot );
+{ assignedMetaTask = (*process->overrideAssigner)( process, slot );
 if( assignedMetaTask != NULL )
 {
 //have work, so reset Done flag (caused by work generated on other core)
-if( process->coreIsDone[coreNum] == TRUE ) //reads are higher perf
+//         if( process->coreIsDone[coreNum] == TRUE ) //reads are higher perf
-process->coreIsDone[coreNum] = FALSE;   //don't just write always
+//            process->coreIsDone[coreNum] = FALSE;   //don't just write always
-switch( assignedMetaTask->taskType )
+//         switch( assignedMetaTask->taskType )
-{ case GenericSlave:  goto AssignSlave;
+//          { case GenericSlave:  goto AssignSlave;
-case SuspendedTask: goto AssignSlave;
+//            case FreeTask:      goto AssignSlave;
-case AtomicTask:    goto AssignNewTask;
+//            case SlotTask:      goto AssignNewTask;
-default:      PR_int__throw_exception( "unknown task type ret by assigner" );
+//            default:      PR_int__throw_exception( "unknown task type ret by assigner" );
-}
+//          }
+//If meta task has a slave attached, then goto assign slave,
+// else it's a new task, so goto where assign it to a slot slave
+if( assignedMetaTask->slaveAssignedTo != NULL )
+goto AssignSlave;
+else
+goto AssignNewTask;
 }
-else
+else //metaTask is NULL, so no work..
 goto NoWork;
 }
 //If here, then no override assigner, so search semantic envs for work
 int32 envIdx, numEnvs; PRSemEnv **semEnvs, *semEnv; SlaveAssigner assigner;
 semEnvs = process->semEnvs;
 numEnvs = process->numSemEnvs;
-for( envIdx = 0; envIdx < numEnvs; envIdx++ ) //keep semEnvs in hash AND array
+for( envIdx = 0; envIdx < numEnvs; envIdx++ ) //keep semEnvs in hash & array
 { semEnv = semEnvs[envIdx];
 if( semEnv->hasWork )
 { assigner = semEnv->slaveAssigner;
 assignedMetaTask = (*assigner)( semEnv, slot );
 //have work, so reset Done flag (caused by work generated on other core)
-if( process->coreIsDone[coreNum] == TRUE ) //reads are higher perf
+//         if( process->coreIsDone[coreNum] == TRUE ) //reads are higher perf
-process->coreIsDone[coreNum] = FALSE;   //don't just write always
+//            process->coreIsDone[coreNum] = FALSE;   //don't just write always
-switch( assignedMetaTask->taskType )
+//         switch( assignedMetaTask->taskType )
-{ case GenericSlave:  goto AssignSlave;
+//          { case GenericSlave: goto AssignSlave;
-case SuspendedTask: goto AssignSlave;
+//            case FreeTask:     goto AssignSlave;
-case AtomicTask:    goto AssignNewTask;
+//            case SlotTask:     goto AssignNewTask;
-default:      PR_int__throw_exception( "unknown task type ret by assigner" );
+//            default:      PR_int__throw_exception( "unknown task type ret by assigner" );
-}
+//          }
+//If meta task has a slave attached, then goto assign slave,
+// else it's a new task, so goto where assign it to a slot slave
+if( assignedMetaTask->slaveAssignedTo != NULL )
+goto AssignSlave;
+else
+goto AssignNewTask;
 }
 }
+//If reach here, then have searched all semEnv's & none have work..
 NoWork:
 //No work, if reach here..
 { goto ReturnTheSlv;
 }
-AssignSlave:     //Have a metaTask attached to a slave, so get the slave out
+AssignSlave: //Have a metaTask attached to a slave, so get the slave & ret it
-{    //get slave pointed to by meta task.
+{ returnSlv = assignedMetaTask->slaveAssignedTo;
-returnSlv = assignedMetaTask->slaveAssignedTo;
 returnSlv->coreAnimatedBy   = coreNum;
 goto ReturnTheSlv;
 }
-AssignNewTask:
+AssignNewTask: //Have a new metaTask that has no slave yet.. assign to slot slv
 {
 //get the slot slave to assign the task to..
-coreNum = slot->coreSlotIsOn;
 slotNum = slot->slotIdx;
 returnSlv = process->slotTaskSlvs[coreNum][slotNum];
-//point slave to task's function, and mark slave as having task
+//point slave to task's function
 PR_int__reset_slaveVP_to_TopLvlFn( returnSlv,
 assignedMetaTask->topLevelFn, assignedMetaTask->initData );
-returnSlv->metaTask          = assignedMetaTask;
+returnSlv->metaTask = assignedMetaTask;
 assignedMetaTask->slaveAssignedTo = returnSlv;
-returnSlv->needsTaskAssigned = FALSE;  //slot slave is a "Task" slave type
+//      returnSlv->needsTaskAssigned = FALSE;  //slot slave is a "Task" slave type
 //have work, so reset Done flag, if was set
-if( process->coreIsDone[coreNum] == TRUE ) //reads are higher perf
+//      if( process->coreIsDone[coreNum] == TRUE ) //reads are higher perf
-process->coreIsDone[coreNum] = FALSE;   //don't just write always
+//         process->coreIsDone[coreNum] = FALSE;   //don't just write always
 goto ReturnTheSlv;
 }
 newSlv->typeOfVP = GenericSlv;
 newSlv->processSlaveIsIn = process;
 process->numLiveGenericSlvs += 1;
 metaTask = PR_int__create_slave_meta_task();
 metaTask->taskID = req->ID;
-metaTask->taskType = GenericSlave;
+//   metaTask->taskType = GenericSlave;
-(*req->handler)(newSlv);
+(*req->handler)( req->semReq, newSlv, requestingSlv, semEnv );
 }
-/*The dissipate handler has to update the number of slaves of the type, within
+/*The dissipate handler has to, sdate the number of slaves of the type, within
 * the process, and call the langlet handler linked into the request,
 * and after that returns, then call the PR function that frees the slave state
 * (or recycles the slave).
 *
 *The PR function that frees the slave state has to also free all of the
 void      *semEnv;
 process = slave->processSlaveIsIn;
 //do the language's dissipate handler
-semEnv = PR_int__give_sem_env_for( slave, slave->request->langMagicNumber );
+semEnv = PR_int__give_sem_env_for_slave( slave, slave->request->langMagicNumber );
-(*slave->request->handler)( slave, semEnv );
+(*slave->request->handler)( slave->request->semReq, slave, semEnv );
 process->numLiveGenericSlvs -= 1;
-PR_int__dissipate_slaveVP_multilang( slave ); //recycles and resets semDatas
+PR_int__recycle_slave_multilang( requestingSlv );
 //check End Of Process Condition
 if( process->numLiveTasks == 0 &&
 process->numLiveGenericSlvs == 0 )
-signalEndOfProcess;
+PR_SS__shutdown_process( process );
 }
 /*Create task is a special form, that has PR behavior in addition to plugin
-* behavior.  Master calls this first, and this in turn calls the plugin's
+* behavior.  Master calls this first, and then calls the plugin's
 * create task handler.
+*
+*Note: the requesting slave must be either generic slave or free task slave
 */
-inline void
+inline PRMetaTask *
-PRHandle_CreateTask( TopLevelFn topLevelFn, void *initData, PRReqst *req,
+PRHandle_CreateTask( PRReqst *req, SlaveVP *requestingSlv )
-SlaveVP *requestingSlv )
+{ PRMetaTask     *metaTask;
-{ PRMetaTask    *metaTask;
+PRProcess      *process;
-PRProcess     *process;
-void          *semEnv, _langMetaTask;
 PRLangMetaTask *langMetaTask;
+PRSemEnv       *semanticEnv;
 process = requestingSlv->processSlaveIsIn;
-metaTask         = PR_int__create_meta_task( req );
+metaTask             = PR_int__create_meta_task( req );
-metaTask->taskID = req->ID; //may be NULL
+metaTask->taskID     = req->ID; //may be NULL
-metaTask->topLevelFn = topLevelFn;
+metaTask->topLevelFn = req->topLevelFn;
-metaTask->initData   = initData;
+metaTask->initData   = req->initData;
 process->numLiveTasks += 1;
-//plugin tracks tasks ready, and has its own assigner, so task doesn't
+semanticEnv = PR_int__give_sem_env_for_slave( slave,
-// come back from lang's handler -- it's consumed and stays in semEnv.
+req->langMagicNumber );
-//But handler gives back the language-specific meta-task it creates, and
-// then hook that into the PR meta-task
+//Do the langlet's create-task handler, which keeps the task
-//(Could also do PRMetaTask as a prolog -- make a Fn that takes the size
+// inside the langlet's sem env, but returns the langMetaTask
-// of the lang's metaTask, and alloc's that plus the prolog and returns
+// so PR can hook it to the PRMetaTask.
-// ptr to position just above the prolog)
+//(Could also do PRMetaTask as a prolog -- make a Fn that takes the size
-semEnv = PR_int__give_semEnv_of_req( req, requestingSlv ); //magic num in req
+// of the lang's metaTask, and alloc's that plus the prolog and returns
-_langMetaTask = (*requestingSlv->request->handler)(req, semEnv);
+// ptr to position just above the prolog)
-langMetaTask  = (PRLangMetaTask *)_langMetaTask;
+langMetaTask = (*req->handler)(req->semReq, slave, semanticEnv);
 metaTask->langMetaTask      = langMetaTask;
 langMetaTask->protoMetaTask = metaTask;
 return;
 }
 /*When a task ends, are two scenarios: 1) task ran to completion, or 2) task
 * suspended at some point in its code.
 * now has nothing more to do, so send it to the recycle Q (which includes
 * freeing all the semData and meta task structs alloc'd for it).  Then
 * decrement the live task count and check end condition.
 *
 *PR has to update count of live tasks, and check end of process condition.
-* There are constructs that wait for a process to end, so when end detected,
+* The "main" can invoke constructs that wait for a process to end, so when
-* have to resume what's waiting..
+* end detected, have to resume what's waiting..
-*Thing is, the wait is used in "main", so it's an OS thread.  That means
+*Thing is, that wait involves the main OS thread.  That means
 * PR internals have to do OS thread signaling.  Want to do that in the
-* core controller, which has the original stack of an OS thread.
+* core controller, which has the original stack of an OS thread.  So the
+* end process handling happens in the core controller.
 *
 *So here, when detect process end, signal to the core controller, which will
 * then do the condition variable notify to the OS thread that's waiting.
+*
+*Note: slave may be either a slot slave or a free task slave.
 */
 inline void
 PRHandle_EndTask( SlaveVP *requestingSlv )
-{ void *semEnv;
+{ void       *semEnv;
-PRReqst *req;
+PRReqst    *req;
-PRMetaTask *metaTask;
+PRLangMetaTask *langMetaTask;
 PRProcess  *process;
 req = requestingSlv->request;
-semEnv = PR_int__give_semEnv_of_req( req, requestingSlv ); //magic num in req
+semEnv = PR_int__give_sem_env_of_req( req, requestingSlv ); //magic num in req
-metaTask = req->metaTask;
+langMetaTask = requestingSlv->metaTask->langMetaTask;
-//Want to keep PRMetaTask hidden from plugin, so extract semReq..
-(*req->handler)( metaTask, req->semReq, semEnv );
+//Do the langlet's request handler
+//Want to keep PR structs hidden from plugin, so extract semReq..
-recycleFreeTaskSlave( requestingSlv );
+(*req->handler)( langMetaTask, req->semReq, semEnv );
+//Now that the langlet's done with it, recycle the slave if it's a freeTaskSlv
+if( requestingSlv->typeOfVP == FreeTaskSlv )
+PR_int__recycle_slave_multilang( requestingSlv );
 process->numLiveTasks -= 1;
 //check End Of Process Condition
 if( process->numLiveTasks == 0 &&
 process->numLiveGenericSlvs == 0 )
-signalEndOfProcessToCoreCtlr;
+//Tell the core controller to do wakeup of any waiting OS thread
+PR_SS__shutdown_process( process );
 }

Mercurial > cgi-bin > hgwebdir.cgi > VMS > VMS_Implementations > VMS_impls > VMS__MC_shared_impl

comparison AnimationMaster.c @ 267:608833ae2c5d