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

comparison AnimationMaster.c @ 272:bc5030385120

Progress -- back to compile process, fixing compile issues

author	Sean Halle <seanhalle@yahoo.com>
date	Tue, 05 Feb 2013 20:23:27 -0800
parents	292393c6bef1
children	40e7625e57bd

comparison

equal deleted inserted replaced

-:77a8dc0f570c
+:1f4f559c0919
 void        PRHandle_CreateSlave_SL(SlaveVP *slave);
 void        PRHandle_Dissipate_SL(SlaveVP *slave);
 void        PR_int__handle_PRServiceReq_SL(SlaveVP *slave);
 */
-inline void PRHandle_CreateTask( PRReqst *req, SlaveVP *slave );
+inline void PRHandle__CreateTask( PRReqst *req, SlaveVP *slave );
-inline void PRHandle_EndTask(    PRReqst *req, SlaveVP *slave );
+inline void PRHandle__EndTask(    PRReqst *req, SlaveVP *slave );
-inline void PRHandle_CreateSlave(PRReqst *req, SlaveVP *slave );
+inline void PRHandle__CreateSlave(PRReqst *req, SlaveVP *slave );
-void        PRHandle_EndSlave(  PRReqst *req, SlaveVP *slave );
+void        PRHandle__EndSlave(  PRReqst *req, SlaveVP *slave );
 //inline void  masterFunction_SingleLang( PRLangEnv *protoLangEnv, AnimSlot *slot );
 inline PRProcess * pickAProcess( AnimSlot *slot );
 inline bool32 assignWork( PRProcess *process, AnimSlot *slot );
-/*The animationMaster embodies most of the animator of the language.  The
-* animator is what emodies the behavior of language constructs.
+/*Note: there used to be a coreController that was another animation
-* As such, it is the animationMaster, in combination with the plugin
+* layer below both the masterVP and the slaveVPs.. in that case, the
-* functions, that make the language constructs do their behavior.
+* masterVP was a virtual processor whose processor-state was the same
-*
+* as a slaveVP's processor sate, both implemented as a SlaveVP struct.
-*Within the code, this is the top-level-function of the masterVPs, and
+* Have removed that, and
-* runs when the coreController has no more slave VPs.  It's job is to
+* changed the masterVP implementation.  Instead of being a special  version
-* refill the animation slots with slaves that have work.
+* of a proto-runtime virtual processor, using the slaveVP stuct, the
-*
+* Master "virtual processor" is now implemented as a pthread pinned to
-*There are multiple versions of the master, each tuned to a specific
+* a physical core.
-* combination of modes.  This keeps the master simple, with reduced overhead,
+*/
-* when the application is not using the extra complexity.
-*
+/*This is the behavior of the Master.  The physical processor switches
-*As of Sept 2012, the versions available will be:
+* between animating the master, and animating a slave.  When a slave
-* 1) Single langauge, which only exposes slaves (such as SSR or Vthread)
+* suspends, the PR "suspend" primitive switches the physical core over
-* 2) Single language, which only exposes tasks  (such as pure dataflow)
+* to animating the masterVP, which is implemented as a pinned pthread.
-* 3) Single language, which exposes both (like Cilk, StarSs, and OpenMP)
+* This function is the behavior of that masterVP.
-* 4) Multi-language, which always assumes both tasks and slaves
+*This function's job is to manage processing
-* 5) Multi-language and multi-process, which also assumes both tasks and slaves
+* requests and to trigger assignment of new work to the physical core,
-*
+* and to manage sharing the core among processes.
-*
+*/
-*
-*/
-//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 *_environment, SlaveVP *masterVP )
-{
-TopEnv         *masterEnv = (TopEnv *)_environment;
-int32           slotIdx;
-AnimSlot       *currSlot;
-//Used while scanning and filling animation slots
-AnimSlot      **animSlots;
-//Local copies, for performance
-int32           thisCoresIdx;
-//======================== Initializations ========================
-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.
-//
-while(1)
-{       MEAS__Capture_Pre_Master_Point
-for( slotIdx = 0; slotIdx < NUM_ANIM_SLOTS; slotIdx++)
-{
-currSlot = animSlots[ slotIdx ];
-masterFunction( currSlot );
-}
-MEAS__Capture_Post_Master_Point;
-masterSwitchToCoreCtlr( masterVP ); //returns when ctlr switches back to master
-flushRegisters();
-}
-}
 inline
 bool32
 masterFunction( AnimSlot  *slot )
 {    //Scan the animation slots
 int32           magicNumber;
 PRReqst        *req;
 PRProcess      *process;
 bool32          foundWork;
 //Check if newly-done slave in slot, which will need request handled
+//NOTE: left over from when had a coreController & MasterVP managed
+// several slots
 if( slot->workIsDone )
 { slot->workIsDone = FALSE;
 slot->needsWorkAssigned = TRUE;
 HOLISTIC__Record_AppResponder_start; //TODO: update to check which process for each slot
 //Handle task create and end first -- they're special cases..
 switch( req->reqType )
 { case TaskEnd:
 { //do PR handler, which calls lang's hdlr and does recycle of
 // free task slave if needed -- PR handler checks for free task Slv
-PRHandle_EndTask( req, slave );                          break;
+PRHandle__EndTask( req, slave );                          break;
 }
 case TaskCreate:
 { //Do PR's create-task handler, which calls the lang's hdlr
 // PR handler checks for free task Slv
-PRHandle_CreateTask( req, slave );                       break;
+PRHandle__CreateTask( req, slave );                       break;
 }
-case SlvCreate:    PRHandle_CreateSlave( req, slave );      break;
+case SlvCreate:    PRHandle__CreateSlave( req, slave );      break;
-case SlvDissipate: PRHandle_EndSlave( req, slave );         break;
+case SlvDissipate: PRHandle__EndSlave( req, slave );         break;
-case Service:      PR_int__handle_PRServiceReq( slave );    break; //resumes into Service lang env
+case Service:      PRHandle__ServiceReq( slave );    break; //resumes into Service lang env
 case Hardware: //for future expansion
 case IO:       //for future expansion
 case OSCall:   //for future expansion
 PR_int__throw_exception("Not implemented", slave, NULL); break;
 case Language: //normal lang request
 MEAS__endReqHdlr;
 HOLISTIC__Record_AppResponder_end;
 } //if have request to be handled
-if( slot->needsWorkAssigned )
+//NOTE: IF statement is leftover from when master managed many slots
+foundWork = FALSE;
+if( slot->needsWorkAssigned ) //can probably remove IF, not that only one slot
 {
 HOLISTIC__Record_Assigner_start;
 //Pick a process to get this slot
 process = pickAProcess( slot );
 //Scan lang environs, looking for langEnv with ready work.
 // call the Assigner for that lang Env, to get a slave for the slot
 foundWork =
 assignWork( process, slot );
 HOLISTIC__Record_Assigner_end;
+//      fixme; //make this a while loop that tries a different process if this one fails
 }//if slot needs slave assigned
 return foundWork;
 }
 *  but am making it possible.
 */
 inline
 bool32
 assignWork( PRProcess *process, AnimSlot *slot )
-{ SlaveVP        *returnSlv;
+{ int32           coreNum;
-int32           coreNum, slotNum;
-PRMetaTask     *assignedMetaTask;
 coreNum = slot->coreSlotIsOn;
 if( process->overrideAssigner != NULL )
 { if( process->numEnvsWithWork != 0 )
 int32 envIdx, numEnvs; PRLangEnv **langEnvsList, *langEnv;
 langEnvsList = process->langEnvsList;
 numEnvs = process->numLangEnvs;
 for( envIdx = 0; envIdx < numEnvs; envIdx++ ) //keep langEnvs in hash & array
 { langEnv = langEnvsList[envIdx];
-if( langEnv->hasWork )
+if( langEnv->numReadyWork > 0 )
-{ (*langEnv->workAssigner)( langEnv, slot ); //assigner calls PR to put slave/task into slot
+{ bool32
-goto ReturnAfterAssigningWork; //quit for-loop, cause found work
+didAssignWork =
+(*langEnv->workAssigner)( langEnv, slot ); //assigner calls PR to put slave/task into slot
+if(didAssignWork)
+{ langEnv->numReadyWork -= 1;
+if( langEnv->numReadyWork == 0 )
+{ process->numEnvsWithWork -= 1;
+}
+goto ReturnAfterAssigningWork; //quit for-loop, 'cause found work
+}
+else
+goto NoWork; //quit for-loop, cause found work
 //NOTE: bad search alg -- should start where left off, then wrap around
 }
 }
 //If reach here, then have searched all langEnv's & none have work..
 NoWork:     //No work, if end up here..
 {
 #ifdef HOLISTIC__TURN_ON_OBSERVE_UCC
-returnSlv = process->idleSlv[coreNum][slotNum];
+returnSlv = process->idleSlv[coreNum][0];  //only one slot now, so [0]
 //things that would normally happen in resume(), but idle VPs
 // never go there
 returnSlv->numTimesAssignedToASlot++; //gives each idle unit a unique ID
 Unit newU;
 *PR itself needs to create the slave, then update numLiveSlaves in process,
 * copy processID from requestor to newly created
 */
 inline
 void
-PRHandle_CreateSlave( PRReqst *req, SlaveVP *slave )
+PRHandle__CreateSlave( PRReqst *req, SlaveVP *slave )
 { SlaveVP   *newSlv;
 PRProcess *process;
 PRLangEnv *protoLangEnv;
 process = slave->processSlaveIsIn;
 protoLangEnv = PR_int__give_proto_lang_env_for_slave__ML( slave, req->langMagicNumber );
-//   newSlv  = PR_int__create_slave( req->topLevelFn, req->initData );
+//create handler, or a future request handler will call PR_PI__make_slave_ready
+// which will in turn handle updating which langlets and which processes have
-//create slv has diff prototype than standard reqst hdlr
+// work available.
+//NOTE: create slv has diff prototype than standard reqst hdlr
 newSlv =
 (*req->createHdlr)(req->langReq, slave, PR_int__give_lang_env(protoLangEnv));
 newSlv->typeOfVP = GenericSlv;
 newSlv->processSlaveIsIn = process;
 newSlv->ID = req->ID;
-process->numLiveGenericSlvs += 1;
+process->numLiveGenericSlvs += 1; //not same as work ready!
 }
 /*The dissipate handler has to, update 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
 * them, then in PR__give_langData( magicNum ) call the langlet registered
 * "resetLangData" Fn.
 */
 inline
 void
-PRHandle_EndSlave( PRReqst *req, SlaveVP *slave )
+PRHandle__EndSlave( PRReqst *req, SlaveVP *slave )
 { PRProcess *process;
 PRLangEnv *protoLangEnv;
 process = slave->processSlaveIsIn;
 protoLangEnv = PR_int__give_proto_lang_env_for_slave__ML( slave, slave->request->langMagicNumber );
 if(req->handler != NULL)
 (*req->handler)( req->langReq, slave, PR_int__give_lang_env(protoLangEnv) );
 process->numLiveGenericSlvs -= 1;
-PR_int__recycle_slave__ML( slave );
+PR_int__recycle_slave( slave );
+//NOTE: dissipate is unrelated to work available (just in case wondering)
 //check End Of Process Condition
 if( process->numLiveTasks == 0 &&
 process->numLiveGenericSlvs == 0 )
-PR_SS__shutdown_process__ML( process );
+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 it then calls the plugin's
 * create task handler.
 *
 *Note: the requesting slave must be either generic slave or free task slave
 */
 inline
 void
-PRHandle_CreateTask( PRReqst *req, SlaveVP *slave )
+PRHandle__CreateTask( PRReqst *req, SlaveVP *slave )
 { PRMetaTask     *metaTask;
 PRProcess      *process;
 PRLangEnv      *protoLangEnv;
 void           *task;
 process->numLiveTasks += 1;
 return;
 }
-/*When a task ends, are two scenarios: 1) task ran to completion, or 2) task
+/*When a task ends, have two scenarios: 1) task ran to completion, or 2) task
-* suspended at some point in its code.
+* has been suspended at some point in its code.
 *For 1, just decr count of live tasks (and check for end condition) -- the
 * master loop will decide what goes into the slot freed up by this task end,
 * so, here, don't worry about assigning a new task to the slot slave.
 *For 2, the task's slot slave has been converted to a free task slave, which
 * now has nothing more to do, so send it to the recycle Q (which includes
 *
 *Note: slave may be either a slot slave or a free task slave.
 */
 inline
 void
-PRHandle_EndTask( PRReqst *req, SlaveVP *requestingSlv )
+PRHandle__EndTask( PRReqst *req, SlaveVP *requestingSlv )
 { void       *langEnv;
 PRProcess  *process;
 void       *langMetaTask;
-langEnv = PR_int__give_lang_env_of_req__ML( req, requestingSlv ); //magic num in req
+langEnv = PR_int__give_lang_env_of_req( req, requestingSlv ); //magic num in req
-langMetaTask = PR_int__give_lang_meta_task_from_slave__ML( requestingSlv, req->langMagicNumber);
+langMetaTask = PR_int__give_lang_meta_task_from_slave( requestingSlv, req->langMagicNumber);
 //Do the langlet's request handler
 //Want to keep PR structs hidden from plugin, so extract langReq..
 (*req->handler)( req->langReq, requestingSlv, langEnv );
 //Now that the langlet's done with it, recycle the slave if it's a freeTaskSlv
 if( requestingSlv->typeOfVP == FreeTaskSlv )
-PR_int__recycle_slave__ML( requestingSlv );
+PR_int__recycle_slave( requestingSlv ); //Doesn't decr num live slaves
 process->numLiveTasks -= 1;
+//NOTE: end-task is unrelated to work available (just in case wondering)
 //check End Of Process Condition
 if( process->numLiveTasks == 0 &&
 process->numLiveGenericSlvs == 0 )
 { //Tell the core controller to do wakeup of any waiting OS thread
-PR_SS__shutdown_process__ML( process );
+PR_SS__shutdown_process( process );
 }
 }
+/*This is for OS requests and PR infrastructure requests, which are not
+* part of the PRServ language -- this is for things that have to be in the
+* infrastructure of PR itself, such as I/O requests, which have to go through
+* pthreads inside the core controller..
+*
+*As of Jan 2013, doesn't do much of anything..
+*/
+void inline
+PRHandle__ServiceReq( SlaveVP *requestingSlv )
+{ PRReqst   *req;
+PRServReq *langReq;
+void      *langEnv;
+int32      magicNumber;
+req = requestingSlv->request;
+magicNumber = req->langMagicNumber;
+langEnv = PR_PI__give_lang_env_for( slave, magicNumber );
+langReq = PR_PI__take_lang_reqst_from(req);
+if( langReq == NULL ) return;
+switch( langReq->reqType )  //lang handlers are all in other file
+{
+case make_probe:      handleMakeProbe(   langReq, langEnv );
+break;
+case throw_excp:  handleThrowException(  langReq, langEnv );
+break;
+}
+}

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

comparison AnimationMaster.c @ 272:bc5030385120