VMS/VMS_Implementations/VSs_impls/VSs__MC_shared

comparison VSs.c @ 37:c8d4f6d3c7d3

hide animating VP and entry point

author	Nina Engelhardt <nengel@mailbox.tu-berlin.de>
date	Wed, 15 May 2013 15:25:55 +0200
parents	227db52cbd93
children	a951b38d2cfc

comparison

equal deleted inserted replaced

-:cf26c0bfa329
+:2a31d1f6f051
 VSs__init_Helper();
 }
-void idle_fn(void* data, SlaveVP *animatingSlv){
+void idle_fn(void* data){
 while(1){
-VMS_int__suspend_slaveVP_and_send_req(animatingSlv);
+VMS_int__suspend_slaveVP_and_send_req(currVP);
 }
 }
 void
 VSs__init_Helper()
 * this.
 *
 *It simply sends a dissipate request, which handles all the state cleanup.
 */
 void
-VSs__end_thread( SlaveVP *thdToEnd )
+VSs__end_thread()
 {
-VMS_WL__send_dissipate_req( thdToEnd );
+VMS_WL__send_dissipate_req( currVP );
 }
 //===========================================================================
 //======================= task submit and end ==============================
 /*
 */
 void
-VSs__submit_task( VSsTaskType *taskType, void *args, SlaveVP *animSlv)
+VSs__submit_task( VSsTaskType *taskType, void *args)
 { VSsSemReq  reqData;
 reqData.reqType    = submit_task;
 reqData.taskType   = taskType;
 reqData.args       = args;
-reqData.callingSlv = animSlv;
+reqData.callingSlv = currVP;
 reqData.taskID     = NULL;
-VMS_WL__send_sem_request( &reqData, animSlv );
+VMS_WL__send_sem_request( &reqData, currVP );
 }
 int32 *
-VSs__create_taskID_of_size( int32 numInts, SlaveVP *animSlv )
+VSs__create_taskID_of_size( int32 numInts)
 { int32 *taskID;
 taskID    = VMS_WL__malloc( sizeof(int32) + numInts * sizeof(int32) );
 taskID[0] = numInts;
 return taskID;
 }
 void
-VSs__submit_task_with_ID( VSsTaskType *taskType, void *args, int32 *taskID,
+VSs__submit_task_with_ID( VSsTaskType *taskType, void *args, int32 *taskID)
-SlaveVP     *animSlv)
 { VSsSemReq  reqData;
 reqData.reqType    = submit_task;
 reqData.taskType   = taskType;
 reqData.args       = args;
 reqData.taskID     = taskID;
-reqData.callingSlv = animSlv;
+reqData.callingSlv = currVP;
-VMS_WL__send_sem_request( &reqData, animSlv );
+VMS_WL__send_sem_request( &reqData, currVP );
 }
 /*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
 * slave from having the core number.
 *
 *But, to stay compatible with all the other VMS languages, leave it in..
 */
 void
-VSs__end_task( SlaveVP *animSlv )
+VSs__end_task()
 { VSsSemReq  reqData;
 reqData.reqType      = end_task;
-reqData.callingSlv   = animSlv;
+reqData.callingSlv   = currVP;
-VMS_WL__send_sem_request( &reqData, animSlv );
+VMS_WL__send_sem_request( &reqData, currVP );
 }
+void plugin__end_VP(){
-void
+VSs__end_task();}
-VSs__taskwait(SlaveVP *animSlv)
+void
+VSs__taskwait()
 {
 VSsSemReq  reqData;
 reqData.reqType      = taskwait;
-reqData.callingSlv   = animSlv;
+reqData.callingSlv   = currVP;
-VMS_WL__send_sem_request( &reqData, animSlv );
+VMS_WL__send_sem_request( &reqData, currVP );
 }
 void
-VSs__taskwait_on(SlaveVP *animSlv,void* ptr){
+VSs__taskwait_on(void* ptr){
 VSsSemReq  reqData;
 reqData.reqType      = taskwait_on;
-reqData.callingSlv   = animSlv;
+reqData.callingSlv   = currVP;
 reqData.args = ptr;
-VMS_WL__send_sem_request( &reqData, animSlv );
+VMS_WL__send_sem_request( &reqData, currVP );
 }
 void
-VSs__start_critical(SlaveVP *animSlv,int32 name){
+VSs__start_critical(int32 name){
 VSsSemReq  reqData;
 reqData.reqType      = critical_start;
-reqData.callingSlv   = animSlv;
+reqData.callingSlv   = currVP;
 reqData.criticalID = name;
-VMS_WL__send_sem_request( &reqData, animSlv );
+VMS_WL__send_sem_request( &reqData, currVP );
 }
 void
-VSs__end_critical(SlaveVP *animSlv,int32 name){
+VSs__end_critical(int32 name){
 VSsSemReq  reqData;
 reqData.reqType      = critical_end;
-reqData.callingSlv   = animSlv;
+reqData.callingSlv   = currVP;
 reqData.criticalID = name;
-VMS_WL__send_sem_request( &reqData, animSlv );
+VMS_WL__send_sem_request( &reqData, currVP );
 }
 //==========================  send and receive ============================
 //
 int32 *
-VSs__give_self_taskID( SlaveVP *animSlv )
+VSs__give_self_taskID()
 {
-return ((VSsSemData*)animSlv->semanticData)->taskStub->taskID;
+return ((VSsSemData*)currVP->semanticData)->taskStub->taskID;
 }
 //================================ send ===================================
 void
-VSs__send_of_type_to( void *msg, const int32 type, int32 *receiverID,
+VSs__send_of_type_to( void *msg, const int32 type, int32 *receiverID)
-SlaveVP *senderSlv )
 { VSsSemReq  reqData;
 reqData.reqType    = send_type_to;
 reqData.msg        = msg;
 reqData.msgType    = type;
 reqData.receiverID = receiverID;
-reqData.senderSlv  = senderSlv;
+reqData.senderSlv  = currVP;
 reqData.nextReqInHashEntry = NULL;
-VMS_WL__send_sem_request( &reqData, senderSlv );
+VMS_WL__send_sem_request( &reqData, currVP );
 //When come back from suspend, no longer own data reachable from msg
 }
 void
-VSs__send_from_to( void *msg, int32 *senderID, int32 *receiverID, SlaveVP *senderSlv )
+VSs__send_from_to( void *msg, int32 *senderID, int32 *receiverID)
 { VSsSemReq  reqData;
 reqData.reqType     = send_from_to;
 reqData.msg         = msg;
 reqData.senderID    = senderID;
 reqData.receiverID  = receiverID;
-reqData.senderSlv   = senderSlv;
+reqData.senderSlv   = currVP;
 reqData.nextReqInHashEntry = NULL;
-VMS_WL__send_sem_request( &reqData, senderSlv );
+VMS_WL__send_sem_request( &reqData, currVP );
 }
 //================================ receive ================================
 * received.  The same receiver can also have send from-to's
 * waiting for it, and those will be kept separate from the "type"
 * messages.
 */
 void *
-VSs__receive_type_to( const int32 type, int32* receiverID, SlaveVP *receiverSlv )
+VSs__receive_type_to( const int32 type, int32* receiverID )
 {       DEBUG__printf1(dbgRqstHdlr,"WL: receive type to %d",receiverID[1] );
 VSsSemReq  reqData;
 reqData.reqType     = receive_type_to;
 reqData.msgType     = type;
 reqData.receiverID  = receiverID;
-reqData.receiverSlv = receiverSlv;
+reqData.receiverSlv = currVP;
 reqData.nextReqInHashEntry = NULL;
-VMS_WL__send_sem_request( &reqData, receiverSlv );
+VMS_WL__send_sem_request( &reqData, currVP );
-return receiverSlv->dataRetFromReq;
+return currVP->dataRetFromReq;
 }
 /*Call this at the point a receiving task wants in-coming data.
 * Use this from-to form when know senderID -- it makes a direct channel
 * between sender and receiver.
 */
 void *
-VSs__receive_from_to( int32 *senderID, int32 *receiverID, SlaveVP *receiverSlv )
+VSs__receive_from_to( int32 *senderID, int32 *receiverID)
 {
 VSsSemReq  reqData;
 reqData.reqType     = receive_from_to;
 reqData.senderID    = senderID;
 reqData.receiverID  = receiverID;
-reqData.receiverSlv = receiverSlv;
+reqData.receiverSlv = currVP;
 reqData.nextReqInHashEntry = NULL;
 DEBUG__printf2(dbgRqstHdlr,"WL: receive from %d to: %d", reqData.senderID[1], reqData.receiverID[1]);
-VMS_WL__send_sem_request( &reqData, receiverSlv );
+VMS_WL__send_sem_request( &reqData, currVP );
-return receiverSlv->dataRetFromReq;
+return currVP->dataRetFromReq;
 }
 /*Fn singleton uses ID as index into array of singleton structs held in the
 * semantic environment.
 */
 void
-VSs__start_fn_singleton( int32 singletonID,   SlaveVP *animSlv )
+VSs__start_fn_singleton( int32 singletonID)
 {
 VSsSemReq  reqData;
 //
 reqData.reqType     = singleton_fn_start;
 reqData.singletonID = singletonID;
-VMS_WL__send_sem_request( &reqData, animSlv );
+VMS_WL__send_sem_request( &reqData, currVP );
-if( animSlv->dataRetFromReq ) //will be 0 or addr of label in end singleton
+if( currVP->dataRetFromReq ) //will be 0 or addr of label in end singleton
 {
-VSsSemEnv *semEnv = VMS_int__give_sem_env_for( animSlv );
+VSsSemEnv *semEnv = VMS_int__give_sem_env_for( currVP );
 asm_write_ret_from_singleton(&(semEnv->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 )
+VSs__start_data_singleton( VSsSingleton **singletonAddr )
 {
 VSsSemReq  reqData;
 if( *singletonAddr && (*singletonAddr)->hasFinished )
 goto JmpToEndSingleton;
 reqData.reqType          = singleton_data_start;
 reqData.singletonPtrAddr = singletonAddr;
-VMS_WL__send_sem_request( &reqData, animSlv );
+VMS_WL__send_sem_request( &reqData, currVP );
-if( animSlv->dataRetFromReq ) //either 0 or end singleton's return addr
+if( currVP->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);
 *
 *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 )
+VSs__end_fn_singleton( int32 singletonID )
 {
 VSsSemReq  reqData;
 //don't need this addr until after at least one singleton has reached
 // this function
-VSsSemEnv *semEnv = VMS_int__give_sem_env_for( animSlv );
+VSsSemEnv *semEnv = VMS_int__give_sem_env_for( currVP );
 asm_write_ret_from_singleton(&(semEnv->fnSingletons[ singletonID]));
 reqData.reqType     = singleton_fn_end;
 reqData.singletonID = singletonID;
-VMS_WL__send_sem_request( &reqData, animSlv );
+VMS_WL__send_sem_request( &reqData, currVP );
 //EndSingletonInstrAddr:
 return;
 }
 void
-VSs__end_data_singleton(  VSsSingleton **singletonPtrAddr, SlaveVP *animSlv )
+VSs__end_data_singleton(  VSsSingleton **singletonPtrAddr )
 {
 VSsSemReq  reqData;
 //don't need this addr until after singleton struct has reached
 // this function for first time
 asm_save_ret_to_singleton(*singletonPtrAddr);
 reqData.reqType          = singleton_data_end;
 reqData.singletonPtrAddr = singletonPtrAddr;
-VMS_WL__send_sem_request( &reqData, animSlv );
+VMS_WL__send_sem_request( &reqData, currVP );
 }
 /*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.
 * 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 )
+void *data )
 {
 VSsSemReq  reqData;
 //
 reqData.reqType          = atomic;
 reqData.fnToExecInMaster = ptrToFnToExecInMaster;
 reqData.dataForFn        = data;
-VMS_WL__send_sem_request( &reqData, animSlv );
+VMS_WL__send_sem_request( &reqData, currVP );
 }
 /*This suspends to the master.
 *First, it looks at the VP's data, to see the highest transactionID that 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 )
+VSs__start_transaction( int32 transactionID )
 {
 VSsSemReq  reqData;
 //
-reqData.callingSlv      = animSlv;
+reqData.callingSlv      = currVP;
 reqData.reqType     = trans_start;
 reqData.transID     = transactionID;
-VMS_WL__send_sem_request( &reqData, animSlv );
+VMS_WL__send_sem_request( &reqData, currVP );
 }
 /*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 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 )
+VSs__end_transaction( int32 transactionID )
 {
 VSsSemReq  reqData;
 //
-reqData.callingSlv      = animSlv;
+reqData.callingSlv      = currVP;
 reqData.reqType     = trans_end;
 reqData.transID     = transactionID;
-VMS_WL__send_sem_request( &reqData, animSlv );
+VMS_WL__send_sem_request( &reqData, currVP );
 }
 //======================== Internal ==================================
 /*
 */
 VMS_WL__send_create_slaveVP_req( &reqData, creatingSlv );
 return creatingSlv->dataRetFromReq;
 }
+int __main_ret;
+void __entry_point(void* _args) {
+__main_args* args = (__main_args*) _args;
+__main_ret = __program_main(args->argc, args->argv);
+VSs__end_thread();
+}
+#undef main
+int main(int argc, char** argv) {
+__main_args args;
+args.argc = argc;
+args.argv = argv;
+VSs__create_seed_slave_and_do_work(__entry_point, (void*) &args);
+return __main_ret;
+}

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

comparison VSs.c @ 37:c8d4f6d3c7d3