VMS/VMS_Implementations/VSs_impls/VSs__MC_shared

comparison VSs.c @ 30:a40859b8dc33

ML_dev -- compiles and runs, may still have shutdown issues

author	Sean Halle <seanhalle@yahoo.com>
date	Sat, 02 Mar 2013 10:07:58 -0800
parents	dd1efbf29ff9
children	0162554f6ef5

comparison

equal deleted inserted replaced

-:210b8fcbd03f
+:e987f33b9210
 {
 return VSs__create_thread_w_ID_and_affinity( fnPtr, initData, thdID,
 ANY_CORE, creatingThd );
 }
-/* old version -- looks safe to delete
-SlaveVP *
-VSs__create_slave_with_affinity( TopLevelFnPtr fnPtr, void *initData,
-SlaveVP *creatingSlv,  int32  coreToAssignOnto )
-{ VSsLangReq  reqData;
-//the lang request data is on the stack and disappears when this
-// call returns -- it's guaranteed to remain in the VP's stack for as
-// long as the VP is suspended.
-reqData.reqType            = create_slave_w_aff; //not used, May 2012
-reqData.coreToAssignOnto   = coreToAssignOnto;
-reqData.fnPtr              = fnPtr;
-reqData.initData           = initData;
-reqData.callingSlv         = creatingSlv;
-PR_WL__send_create_slaveVP_req( &reqData, creatingSlv, VSs_MAGIC_NUMBER );
-return creatingSlv->dataRetFromReq;
-}
-*/
 SlaveVP *
 VSs__create_thread_w_ID_and_affinity( TopLevelFnPtr fnPtr,   void *initData,
 int32 *thdID, int32 coreToAssignOnto, SlaveVP *creatingThd )
 reqData.reqType          = create_slave; //know type because in a PR create req
 reqData.coreToAssignOnto = coreToAssignOnto;
 reqData.fnPtr            = fnPtr;
 reqData.initData         = initData;
-PR_WL__send_create_slaveVP_req( &reqData, thdID, (CreateHandler)&handleCreateThd,
+PR_WL__send_create_slaveVP_req( &reqData, thdID, (CreateHandler)&VSs__handleCreateThd,
 creatingThd, VSs_MAGIC_NUMBER );
 return (SlaveVP *)creatingThd->dataRetFromReq;
 }
 /*This is always the last thing done in the code animated by a thread VP.
 */
 void
 VSs__end_thread( SlaveVP *thdToEnd )
 {
 //the lang request is null for VSs version of end slave
-PR_WL__send_end_slave_req( NULL, (RequestHandler)&handleDissipate, thdToEnd,
+PR_WL__send_end_slave_req( NULL, (RequestHandler)&VSs__handleDissipate, thdToEnd,
 VSs_MAGIC_NUMBER );
 }
 //Create task is a special form, so have to pass as parameters, the
 // top-level-fn of task and the data for that fn, plus lang's req,
 // animating slave, and lang's magic number
 PR_WL__send_create_task_req( taskType->fn, args, &reqData, NO_ID,
-&handleSubmitTask, animSlv, VSs_MAGIC_NUMBER );
+&VSs__handleSubmitTask, animSlv, VSs_MAGIC_NUMBER );
 }
 void
 VSs__submit_task_with_ID( VSsTaskType *taskType, void *args, int32 *taskID,
 SlaveVP     *animSlv )
 { VSsLangReq  reqData;
 reqData.reqType    = submit_task;
-reqData.taskType   = taskType;
+reqData.taskType   = taskType; //VSs info about args, dependencies, etc
 reqData.args       = args;
 reqData.callingSlv = animSlv;
 PR_WL__send_create_task_req( taskType->fn, args, &reqData, taskID,
-&handleSubmitTask, animSlv, VSs_MAGIC_NUMBER );
+&VSs__handleSubmitTask, animSlv, VSs_MAGIC_NUMBER );
 }
 /*This call is the last to happen in every task.  It causes the slave to
 * suspend and get the next task out of the task-queue.  Notice there is no
 void
 VSs__end_task( SlaveVP *animSlv )
 { VSsLangReq  reqData;
 //VSs has nothing extra to communicate to end task handler, so lang req is NULL
-PR_WL__send_end_task_request( NULL, &handleEndTask, animSlv, VSs_MAGIC_NUMBER );
+PR_WL__send_end_task_request( NULL, &VSs__handleEndTask, animSlv, VSs_MAGIC_NUMBER );
 }
 /*Waits for all tasks that are direct children to end, then resumes calling
 * task or thread
 VSsLangReq  reqData;
 reqData.reqType      = taskwait;
 reqData.callingSlv   = animSlv;
-PR_WL__send_lang_request( &reqData, (RequestHandler)&handleTaskwait, animSlv,
+PR_WL__send_lang_request( &reqData, (RequestHandler)&VSs__handleTaskwait, animSlv,
 VSs_MAGIC_NUMBER );
 }
+void
+VSs__wait_for_all_VSs_created_work_to_end( SlaveVP *seedSlv )
+{
+VSsLangReq  reqData;
+reqData.reqType      = activity_cease_wait;
+reqData.callingSlv   = seedSlv;
+PR_WL__send_lang_request( &reqData, (RequestHandler)&VSs__handleWaitForVSsWorkToEnd, seedSlv,
+VSs_MAGIC_NUMBER );
+}
+/*This is called by the application -- normally the seed slave.  It causes a
+* request to be sent that frees the VSs lang env and all its contents.
+*The seed slave resumes from the built-in PRServ langlet's environment.  It
+* will be PRServ that causes return from this call.
+*/
+void
+VSs__shutdown( SlaveVP *seedSlv )
+{
+PR_WL__send_lang_shutdown_request( seedSlv, VSs_MAGIC_NUMBER );
+}
 //==========================  send and receive ============================
 //
 inline
 int32 *
 VSs__give_self_taskID( SlaveVP *animSlv )
-{
+{ void *metaTask;
-return PR__give_ID_from_slave( animSlv, VSs_MAGIC_NUMBER );
+metaTask = PR_WL__give_lang_meta_task_from_slave( animSlv, VSs_MAGIC_NUMBER );
+return PR__give_ID_from_lang_meta_task( metaTask );
 }
 //================================ send ===================================
 void
 reqData.receiverID = receiverID;
 reqData.senderSlv  = senderSlv;
 reqData.nextReqInHashEntry = NULL;
-PR_WL__send_lang_request( &reqData, (RequestHandler)&handleSendTypeTo,
+PR_WL__send_lang_request( &reqData, (RequestHandler)&VSs__handleSendTypeTo,
 senderSlv, VSs_MAGIC_NUMBER );
 //When come back from suspend, no longer own data reachable from msg
 }
 reqData.receiverID  = receiverID;
 reqData.senderSlv   = senderSlv;
 reqData.nextReqInHashEntry = NULL;
-PR_WL__send_lang_request( &reqData, (RequestHandler)&handleSendFromTo,
+PR_WL__send_lang_request( &reqData, (RequestHandler)&VSs__handleSendFromTo,
 senderSlv, VSs_MAGIC_NUMBER );
 }
 //================================ receive ================================
 reqData.receiverID  = receiverID;
 reqData.receiverSlv = receiverSlv;
 reqData.nextReqInHashEntry = NULL;
-PR_WL__send_lang_request( &reqData, (RequestHandler)&handleReceiveTypeTo,
+PR_WL__send_lang_request( &reqData, (RequestHandler)&VSs__handleReceiveTypeTo,
 receiverSlv, VSs_MAGIC_NUMBER );
 return receiverSlv->dataRetFromReq;
 }
 reqData.receiverSlv = receiverSlv;
 reqData.nextReqInHashEntry = NULL;
 DEBUG__printf2(dbgRqstHdlr,"WL: receive from %d to: %d", reqData.senderID[1], reqData.receiverID[1]);
-PR_WL__send_lang_request( &reqData, (RequestHandler)&handleReceiveFromTo,
+PR_WL__send_lang_request( &reqData, (RequestHandler)&VSs__handleReceiveFromTo,
 receiverSlv, VSs_MAGIC_NUMBER );
 return receiverSlv->dataRetFromReq;
 }
-//==========================================================================
-//
-/*A function singleton is a function whose body executes exactly once, on a
-* single core, no matter how many times the fuction is called and no
-* matter how many cores or the timing of cores calling it.
-*
-*A data singleton is a ticket attached to data.  That ticket can be used
-* to get the data through the function exactly once, no matter how many
-* times the data is given to the function, and no matter the timing of
-* trying to get the data through from different cores.
-*/
-/*asm function declarations*/
-void asm_save_ret_to_singleton(VSsSingleton *singletonPtrAddr);
-void asm_write_ret_from_singleton(VSsSingleton *singletonPtrAddr);
-/*Fn singleton uses ID as index into array of singleton structs held in the
-* language environment.
-*/
-void
-VSs__start_fn_singleton( int32 singletonID,   SlaveVP *animSlv )
-{
-VSsLangReq  reqData;
-//
-reqData.reqType     = singleton_fn_start;
-reqData.singletonID = singletonID;
-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( animSlv, VSs_MAGIC_NUMBER );
-asm_write_ret_from_singleton(&(langEnv->fnSingletons[ singletonID]));
-}
-}
-/*Data singleton hands addr of loc holding a pointer to a singleton struct.
-* The start_data_singleton makes the structure and puts its addr into the
-* location.
-*/
-void
-VSs__start_data_singleton( VSsSingleton **singletonAddr,  SlaveVP *animSlv )
-{
-VSsLangReq  reqData;
-if( *singletonAddr && (*singletonAddr)->hasFinished )
-goto JmpToEndSingleton;
-reqData.reqType          = singleton_data_start;
-reqData.singletonPtrAddr = singletonAddr;
-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
-//The return addr is at 0x4(%%ebp)
-JmpToEndSingleton:
-asm_write_ret_from_singleton(*singletonAddr);
-}
-//now, simply return
-//will exit either from the start singleton call or the end-singleton call
-}
-/*Uses ID as index into array of flags.  If flag already set, resumes from
-* end-label.  Else, sets flag and resumes normally.
-*
-*Note, this call cannot be inlined because the instr addr at the label
-* inside is shared by all invocations of a given singleton ID.
-*/
-void
-VSs__end_fn_singleton( int32 singletonID, SlaveVP *animSlv )
-{
-VSsLangReq  reqData;
-//don't need this addr until after at least one singleton has reached
-// this function
-VSsLangEnv *
-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, (RequestHandler)&handleEndFnSingleton,
-animSlv, VSs_MAGIC_NUMBER );
-EndSingletonInstrAddr:
-return;
-}
-void
-VSs__end_data_singleton(  VSsSingleton **singletonPtrAddr, SlaveVP *animSlv )
-{
-VSsLangReq  reqData;
-//don't need this addr until after singleton struct has reached
-// this function for first time
-//do assembly that saves the return addr of this fn call into the
-// data singleton -- that data-singleton can only be given to exactly
-// one instance in the code of this function.  However, can use this
-// function in different places for different data-singletons.
-asm_save_ret_to_singleton(*singletonPtrAddr);
-reqData.reqType          = singleton_data_end;
-reqData.singletonPtrAddr = singletonPtrAddr;
-PR_WL__send_lang_request( &reqData, (RequestHandler)&handleEndDataSingleton,
-animSlv, VSs_MAGIC_NUMBER );
-}
-/*This executes the function in the masterVP, so it executes in isolation
-* from any other copies -- only one copy of the function can ever execute
-* at a time.
-*
-*It suspends to the master, and the request handler takes the function
-* pointer out of the request and calls it, then resumes the VP.
-*Only very short functions should be called this way -- for longer-running
-* isolation, use transaction-start and transaction-end, which run the code
-* between as work-code.
-*/
-void
-VSs__animate_short_fn_in_isolation( PtrToAtomicFn ptrToFnToExecInMaster,
-void *data, SlaveVP *animSlv )
-{
-VSsLangReq  reqData;
-//
-reqData.reqType          = atomic;
-reqData.fnToExecInMaster = ptrToFnToExecInMaster;
-reqData.dataForFn        = data;
-PR_WL__send_lang_request( &reqData, (RequestHandler)&handleAtomic,
-animSlv, VSs_MAGIC_NUMBER );
-}
-/*This suspends to the master.
-*First, it looks at the VP's data, to see the highest transactionID that VP
-* already has entered.  If the current ID is not larger, it throws an
-* exception stating a bug in the code.  Otherwise it puts the current ID
-* there, and adds the ID to a linked list of IDs entered -- the list is
-* used to check that exits are properly ordered.
-*Next it is uses transactionID as index into an array of transaction
-* structures.
-*If the "VP_currently_executing" field is non-null, then put requesting VP
-* into queue in the struct.  (At some point a holder will request
-* end-transaction, which will take this VP from the queue and resume it.)
-*If NULL, then write requesting into the field and resume.
-*/
-void
-VSs__start_transaction( int32 transactionID, SlaveVP *animSlv )
-{
-VSsLangReq  reqData;
-//
-reqData.callingSlv  = animSlv;
-reqData.reqType     = trans_start;
-reqData.transID     = transactionID;
-PR_WL__send_lang_request( &reqData, (RequestHandler)&handleTransStart,
-animSlv, VSs_MAGIC_NUMBER );
-}
-/*This suspends to the master, then uses transactionID as index into an
-* array of transaction structures.
-*It looks at VP_currently_executing to be sure it's same as requesting VP.
-* If different, throws an exception, stating there's a bug in the code.
-*Next it looks at the queue in the structure.
-*If it's empty, it sets VP_currently_executing field to NULL and resumes.
-*If something in, gets it, sets VP_currently_executing to that VP, then
-* resumes both.
-*/
-void
-VSs__end_transaction( int32 transactionID, SlaveVP *animSlv )
-{
-VSsLangReq  reqData;
-//
-reqData.callingSlv      = animSlv;
-reqData.reqType     = trans_end;
-reqData.transID     = transactionID;
-PR_WL__send_lang_request( &reqData, (RequestHandler)&handleTransEnd,
-animSlv, VSs_MAGIC_NUMBER );
-}
-//======================== Internal ==================================

Mercurial > cgi-bin > hgwebdir.cgi > VMS > VMS_Implementations > VSs_impls > VSs__MC_shared_impl

comparison VSs.c @ 30:a40859b8dc33