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

comparison AnimationMaster.c @ 273:40e7625e57bd

Compiles and runs, up to end of process, working on end process and shutdown

author	Sean Halle <seanhalle@yahoo.com>
date	Sat, 02 Mar 2013 09:43:45 -0800
parents	bc5030385120
children	1d7ea1b0f176

comparison

equal deleted inserted replaced

-:1f4f559c0919
+:cb4417c0c163
 #include <stddef.h>
 #include "PR.h"
 #include "VSs_impl/VSs.h"
-/*
+//=========================  Local Declarations  ========================
-void        PRHandle_CreateTask_SL(SlaveVP *slave);
+inline PRProcess *
+pickAProcess( AnimSlot *slot );
-void        PRHandle_CreateSlave_SL(SlaveVP *slave);
+inline bool32
-void        PRHandle_Dissipate_SL(SlaveVP *slave);
+assignWork( PRProcess *process, AnimSlot *slot );
-void        PR_int__handle_PRServiceReq_SL(SlaveVP *slave);
-*/
+inline void
-inline void PRHandle__CreateTask( PRReqst *req, SlaveVP *slave );
+PRHandle__CreateTask( PRReqst *req, SlaveVP *slave );
-inline void PRHandle__EndTask(    PRReqst *req, SlaveVP *slave );
+inline void
-inline void PRHandle__CreateSlave(PRReqst *req, SlaveVP *slave );
+PRHandle__EndTask(    PRReqst *req, SlaveVP *slave );
-void        PRHandle__EndSlave(  PRReqst *req, SlaveVP *slave );
+inline void
+PRHandle__CreateSlave(PRReqst *req, SlaveVP *slave );
+inline void
-//inline void  masterFunction_SingleLang( PRLangEnv *protoLangEnv, AnimSlot *slot );
+PRHandle__EndSlave(   PRReqst *req, SlaveVP *slave );
-inline PRProcess * pickAProcess( AnimSlot *slot );
-inline bool32 assignWork( PRProcess *process, AnimSlot *slot );
+inline void
+PRHandle__LangShutdown( PRReqst *req, SlaveVP *requestingSlv );
+inline void
+handleMakeProbe( PRServiceReq *langReq, PRLangEnv *protoLangEnv );
+inline void
+handleThrowException( PRServiceReq *langReq, PRLangEnv *protoLangEnv );
+//===========================================================================
 /*Note: there used to be a coreController that was another animation
 * layer below both the masterVP and the slaveVPs.. in that case, the
 * masterVP was a virtual processor whose processor-state was the same
 * as a slaveVP's processor sate, both implemented as a SlaveVP struct.
 int32           magicNumber;
 SlaveVP        *slave;
 PRLangEnv      *langEnv;
 PRReqst        *req;
 PRProcess      *process;
-bool32          foundWork;
+bool32          didAssignWork;
 //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
+//An Idle VP has no request to handle, so skip to assign..
-MEAS__startReqHdlr;
+if( slot->slaveAssignedToSlot->typeOfVP != IdleVP )
+{
+HOLISTIC__Record_AppResponder_start; //TODO: update to check which process for each slot
-//process the request made by the slave (held inside slave struc)
+MEAS__startReqHdlr;
-slave = slot->slaveAssignedToSlot;
-req = slave->request;
+//process the request made by the slave (held inside slave struc)
-//If the requesting slave is a slot slave, and request is not
+slave = slot->slaveAssignedToSlot;
-// task-end, then turn it into a free task slave.
+req = slave->request;
-if( slave->typeOfVP == SlotTaskSlv && req->reqType != TaskEnd )
-PR_int__replace_with_new_slot_slv( slave );
+//If the requesting slave is a slot slave, and request is not
+// task-end, then turn it into a free task slave & continue
-//Handle task create and end first -- they're special cases..
+if( slave->typeOfVP == SlotTaskSlv && req->reqType != TaskEnd )
-switch( req->reqType )
+PR_int__replace_with_new_slot_slv( slave );
-{ case TaskEnd:
-{ //do PR handler, which calls lang's hdlr and does recycle of
+//Handle task create and end first -- they're special cases..
-// free task slave if needed -- PR handler checks for free task Slv
+switch( req->reqType )
-PRHandle__EndTask( req, slave );                          break;
+{ 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;
+}
+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;
+}
+case SlvCreate:    PRHandle__CreateSlave( req, slave );      break;
+case SlvDissipate: PRHandle__EndSlave( req, slave );         break;
+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 LangShutdown: PRHandle__LangShutdown( req, slave ); break;
+case Language: //normal lang request
+{ magicNumber = req->langMagicNumber;
+langEnv = PR_PI__give_lang_env_for_slave( slave, magicNumber );
+(*req->handler)( req->langReq, slave, langEnv );
+}
 }
-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;
-}
-case SlvCreate:    PRHandle__CreateSlave( req, slave );      break;
-case SlvDissipate: PRHandle__EndSlave( req, slave );         break;
-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
-{ magicNumber = req->langMagicNumber;
-langEnv = PR_PI__give_lang_env_for( slave, magicNumber );
-(*req->handler)( req->langReq, slave, langEnv );
-}
-}
 MEAS__endReqHdlr;
 HOLISTIC__Record_AppResponder_end;
+}//if not idleVP
 } //if have request to be handled
 //NOTE: IF statement is leftover from when master managed many slots
-foundWork = FALSE;
+didAssignWork = FALSE;
-if( slot->needsWorkAssigned ) //can probably remove IF, not that only one slot
+if( slot->needsWorkAssigned ) //can probably remove IF, now 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 =
+if( process != NULL )
-assignWork( process, slot );
+{ didAssignWork =
+assignWork( process, slot );
+}
 HOLISTIC__Record_Assigner_end;
-//      fixme; //make this a while loop that tries a different process if this one fails
+if( !didAssignWork ) //if no work assigned, be sure idle slave is in slot
+{ slot->slaveAssignedToSlot = _PRTopEnv->idleSlv[slot->coreSlotIsOn][0];
+}
+//      fixme; //make into a loop that tries more processes if fails to assign
 }//if slot needs slave assigned
-return foundWork;
+return didAssignWork;
 }
 /*When several processes exist, use some pattern for picking one to give
 * the animation slot to.
 *First, it has to be a process that has work available.
 else
 goto NoWork;
 }
 //If here, then no override assigner, so search language envs for work
-int32 envIdx, numEnvs; PRLangEnv **langEnvsList, *langEnv;
+int32 envIdx, numEnvs; PRLangEnv **protoLangEnvsList, *protoLangEnv;
-langEnvsList = process->langEnvsList;
+protoLangEnvsList = process->protoLangEnvsList;
 numEnvs = process->numLangEnvs;
 for( envIdx = 0; envIdx < numEnvs; envIdx++ ) //keep langEnvs in hash & array
-{ langEnv = langEnvsList[envIdx];
+{ protoLangEnv = protoLangEnvsList[envIdx];
-if( langEnv->numReadyWork > 0 )
+if( protoLangEnv->numReadyWork > 0 )
 { bool32
 didAssignWork =
-(*langEnv->workAssigner)( langEnv, slot ); //assigner calls PR to put slave/task into slot
+(*protoLangEnv->workAssigner)( PR_int__give_lang_env(protoLangEnv), slot ); //assigner calls PR to put slave/task into slot
 if(didAssignWork)
-{ langEnv->numReadyWork -= 1;
+{ protoLangEnv->numReadyWork -= 1;
-if( langEnv->numReadyWork == 0 )
+if( protoLangEnv->numReadyWork == 0 )
 { process->numEnvsWithWork -= 1;
 }
 goto ReturnAfterAssigningWork; //quit for-loop, 'cause found work
 }
 else
 ReturnAfterAssigningWork:  //All paths goto here.. to provide single point for holistic..
 {
 HOLISTIC__Record_Assigner_end;
 return TRUE;
+}
+}
+//=================================
+//===
+//=
+/*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 )
+{ PRMetaTask     *protoMetaTask;
+PRProcess      *process;
+PRLangEnv      *protoLangEnv;
+void           *task;
+process = slave->processSlaveIsIn;
+protoLangEnv = PR_int__give_proto_lang_env_for_slave( slave,
+req->langMagicNumber );
+//Do the langlet's create-task handler, which keeps the task
+// inside the langlet's lang env, but returns the langMetaTask
+// so that PR can then put stuff into the prolog
+//typedef void * (*CreateHandler)( void *, SlaveVP *, void * ); //req, slv, langEnv
+//
+task =
+(*req->createHdlr)(req->langReq, slave, PR_int__give_lang_env(protoLangEnv) );
+protoMetaTask = PR_int__give_prolog_of_lang_meta_task( task );
+protoMetaTask->ID         = req->ID; //may be NULL
+protoMetaTask->topLevelFn = req->topLevelFn;
+protoMetaTask->initData   = req->initData;
+protoMetaTask->processTaskIsIn = process;
+process->numLiveTasks += 1;
+protoLangEnv->numLiveWork += 1;  //used in wait statements -- small added overhead
+return;
+}
+/*When a task ends, have two scenarios: 1) task ran to completion, or 2) task
+* 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
+* freeing all the langData 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.
+* The "main" can invoke constructs that wait for a process to end, so when
+* end detected, have to resume what's waiting..
+*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.  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( PRReqst *req, SlaveVP *requestingSlv )
+{ void       *langEnv;
+PRLangEnv  *protoLangEnv;
+PRProcess  *process;
+void       *langMetaTask;
+process = requestingSlv->processSlaveIsIn;
+langEnv = PR_int__give_lang_env_of_req( req, requestingSlv ); //magic num in req
+protoLangEnv = PR_int__give_proto_lang_env( langEnv );
+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..
+//This is supposed to free any langlet-malloc'd mem, including meta task
+(*req->handler)( req->langReq, requestingSlv, langEnv );
+protoLangEnv->numLiveWork -= 1;  //used in wait statements -- small added overhead
+if( protoLangEnv->numLiveWork == 0 &&
+numInPrivQ( protoLangEnv->waitingForWorkToEndQ ) > 0 )
+{ SlaveVP *
+waitingSlave = readPrivQ( protoLangEnv->waitingForWorkToEndQ );
+//can't resume into langlet that just ended its last work!
+// and don't have env that the waiter was created in, so resume
+// into PRServ env..
+void *
+resumeEnv = PR_PI__give_lang_env_from_process( process, PRServ_MAGIC_NUMBER );
+while( waitingSlave != NULL )
+{    //resume a slave that was waiting for work in this env to finish
+PR_PI__make_slave_ready( waitingSlave, resumeEnv );
+//get next waiting slave, repeat..
+waitingSlave = readPrivQ( protoLangEnv->waitingForWorkToEndQ );
+}
+}
+//Now that the langlet's done with it, recycle the slave if it's a freeTaskSlv
+if( requestingSlv->typeOfVP == FreeTaskSlv )
+PR_int__recycle_slaveVP( 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__end_process_normally( process );
 }
 }
 { SlaveVP   *newSlv;
 PRProcess *process;
 PRLangEnv *protoLangEnv;
 process = slave->processSlaveIsIn;
-protoLangEnv = PR_int__give_proto_lang_env_for_slave__ML( slave, req->langMagicNumber );
+protoLangEnv = PR_int__give_proto_lang_env_for_slave( slave, req->langMagicNumber );
 //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
 // work available.
 //NOTE: create slv has diff prototype than standard reqst hdlr
 newSlv->typeOfVP = GenericSlv;
 newSlv->processSlaveIsIn = process;
 newSlv->ID = req->ID;
 process->numLiveGenericSlvs += 1; //not same as work ready!
+protoLangEnv->numLiveWork += 1;  //used in wait statements -- small added overhead
 }
 /*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
 PRLangEnv *protoLangEnv;
 process = slave->processSlaveIsIn;
 //do the language's dissipate handler
-protoLangEnv = PR_int__give_proto_lang_env_for_slave__ML( slave, slave->request->langMagicNumber );
+protoLangEnv = PR_int__give_proto_lang_env_for_slave( slave, slave->request->langMagicNumber );
 if(req->handler != NULL)
 (*req->handler)( req->langReq, slave, PR_int__give_lang_env(protoLangEnv) );
+protoLangEnv->numLiveWork -= 1;  //used in wait statements -- small added overhead
+if( protoLangEnv->numLiveWork == 0 &&
+numInPrivQ( protoLangEnv->waitingForWorkToEndQ ) > 0 )
+{ SlaveVP *
+waitingSlave = readPrivQ( protoLangEnv->waitingForWorkToEndQ );
+//can't resume into langlet that just ended its last work!
+// and don't have env that the waiter was created in, so resume
+// into PRServ env..
+void *
+resumeEnv = PR_PI__give_lang_env_from_process( process, PRServ_MAGIC_NUMBER );
+while( waitingSlave != NULL )
+{    //resume a slave that was waiting for work in this env to finish
+PR_PI__make_slave_ready( waitingSlave, resumeEnv );
+//get next waiting slave, repeat..
+waitingSlave = readPrivQ( protoLangEnv->waitingForWorkToEndQ );
+}
+}
 process->numLiveGenericSlvs -= 1;
-PR_int__recycle_slave( slave );
+PR_int__recycle_slaveVP( 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( process );
+PR_SS__end_process_normally( 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.
+//=
-*
+/*Langlet shutdown triggers this, which calls the registered shutdown
-*Note: the requesting slave must be either generic slave or free task slave
+* handler for the langlet, and removes the lang's env from the process
 */
 inline
 void
-PRHandle__CreateTask( PRReqst *req, SlaveVP *slave )
+PRHandle__LangShutdown( PRReqst *req, SlaveVP *requestingSlv )
-{ PRMetaTask     *metaTask;
-PRProcess      *process;
-PRLangEnv      *protoLangEnv;
-void           *task;
-process = slave->processSlaveIsIn;
-protoLangEnv = PR_int__give_proto_lang_env_for_slave__ML( slave,
-req->langMagicNumber );
-//Do the langlet's create-task handler, which keeps the task
-// inside the langlet's lang env, but returns the langMetaTask
-// so PR can put stuff into the prolog
-task =
-(*req->createHdlr)(req->langReq, slave, PR_int__give_lang_env(protoLangEnv) );
-metaTask = PR_int__give_prolog_of_task( task );
-metaTask->ID         = req->ID; //may be NULL
-metaTask->topLevelFn = req->topLevelFn;
-metaTask->initData   = req->initData;
-process->numLiveTasks += 1;
-return;
-}
-/*When a task ends, have two scenarios: 1) task ran to completion, or 2) task
-* 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
-* freeing all the langData 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.
-* The "main" can invoke constructs that wait for a process to end, so when
-* end detected, have to resume what's waiting..
-*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.  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( PRReqst *req, SlaveVP *requestingSlv )
 { void       *langEnv;
+PRLangEnv  *protoLangEnv;
 PRProcess  *process;
-void       *langMetaTask;
+process = requestingSlv->processSlaveIsIn;
-langEnv = PR_int__give_lang_env_of_req( req, requestingSlv ); //magic num in req
+protoLangEnv = PR_int__give_proto_lang_env_from_process( process, req->langMagicNumber );
-langMetaTask = PR_int__give_lang_meta_task_from_slave( requestingSlv, req->langMagicNumber);
+langEnv = PR_int__give_lang_env( protoLangEnv );
-//Do the langlet's request handler
+//call the langlet's registered handler
-//Want to keep PR structs hidden from plugin, so extract langReq..
+(*protoLangEnv->shutdownHdlr)( langEnv );
-(*req->handler)( req->langReq, requestingSlv, langEnv );
+PR_int__remove_lang_env_from_process_and_free( langEnv ); //removes from process and frees
-//Now that the langlet's done with it, recycle the slave if it's a freeTaskSlv
-if( requestingSlv->typeOfVP == FreeTaskSlv )
-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( 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
 *
 *As of Jan 2013, doesn't do much of anything..
 */
 void inline
 PRHandle__ServiceReq( SlaveVP *requestingSlv )
-{ PRReqst   *req;
+{ PRReqst      *req;
-PRServReq *langReq;
+PRServiceReq *langReq;
-void      *langEnv;
+PRLangEnv    *protoLangEnv;
-int32      magicNumber;
+int32         magicNumber;
 req = requestingSlv->request;
 magicNumber = req->langMagicNumber;
-langEnv = PR_PI__give_lang_env_for( slave, magicNumber );
+protoLangEnv = PR_int__give_proto_lang_env_for_slave( requestingSlv, 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 );
+case make_probe:      handleMakeProbe(   langReq, protoLangEnv );
 break;
-case throw_excp:  handleThrowException(  langReq, langEnv );
+case throw_excp:  handleThrowException(  langReq, protoLangEnv );
 break;
 }
 }
+/*These handlers are special -- they don't belong to a language, because they
+* deal with things internal to PR, so put them here..
+*/
+inline
+void
+handleMakeProbe( PRServiceReq *langReq, PRLangEnv *protoLangEnv )
+{ IntervalProbe *newProbe;
+newProbe          = PR_int__malloc( sizeof(IntervalProbe) );
+newProbe->nameStr = PR_int__strDup( langReq->nameStr );
+newProbe->hist    = NULL;
+newProbe->schedChoiceWasRecorded = FALSE;
+//This runs in masterVP, so no race-condition worries
+//BUG: move to process
+newProbe->probeID =
+addToDynArray( newProbe, _PRTopEnv->dynIntervalProbesInfo );
+langReq->requestingSlv->dataRetFromReq = newProbe;
+(*protoLangEnv->makeSlaveReadyFn)( langReq->requestingSlv, PR_int__give_lang_env(protoLangEnv) );
+}
+inline
+void
+handleThrowException( PRServiceReq *langReq, PRLangEnv *protoLangEnv )
+{
+PR_int__throw_exception(  langReq->msgStr, langReq->requestingSlv, langReq->exceptionData );
+(*protoLangEnv->makeSlaveReadyFn)( langReq->requestingSlv, PR_int__give_lang_env(protoLangEnv) );
+}

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

comparison AnimationMaster.c @ 273:40e7625e57bd