VMS/VMS_Implementations/VMS_impls/VMS__MC_shared

comparison VMS.c @ 24:2b161e1a50ee

1st working version -- as far as can tell due to SEH bugs

author	Me
date	Wed, 07 Jul 2010 13:15:54 -0700
parents	1dbc7f6e3e67
children	c556193f7211

comparison

equal deleted inserted replaced

-:641e4ced0df8
+:c6b65a94790f
 //Set slot 0 to be the master virt procr & set flags just in case
 masterEnv->schedSlots[0]->needsProcrAssigned  = FALSE;  //says don't touch
 masterEnv->schedSlots[0]->workIsDone          = FALSE;  //says don't touch
 masterEnv->schedSlots[0]->procrAssignedToSlot = masterEnv->masterVirtPr;
 masterEnv->masterVirtPr->schedSlot = masterEnv->schedSlots[0];
+masterEnv->stillRunning = FALSE;
 //First core loop to start up gets this, which will schedule seed Pr
 //TODO: debug: check address of masterVirtPr
 writeCASQ( masterEnv->masterVirtPr, workQ );
 numProcrsCreated = 1;
+//========================================================================
+//                      Create the Threads
+int coreIdx;
+//Make params given to the win threads that animate the core loops
+for( coreIdx=0; coreIdx < NUM_CORES; coreIdx++ )
+{ coreLoopThdParams[coreIdx]          = malloc( sizeof(ThdParams) );
+coreLoopThdParams[coreIdx]->coreNum = coreIdx;
+//make the core loop threads, born in suspended state
+coreLoopThdHandles[ coreIdx ] =
+CreateThread ( NULL, // Security attributes
+0, // Stack size
+coreLoop,
+coreLoopThdParams[coreIdx],
+CREATE_SUSPENDED,
+&(coreLoopThdIds[coreIdx])
+);
+}
 }
 void
 create_sched_slots( MasterEnv *masterEnv )
 }
 /*Semantic layer calls this when it want the system to start running..
 *
-*This creates the core loops, pins them to physical cores, gives them the
+*This starts the core loops running then waits for them to exit.
-* pointer to the workQ, and starts them running.
+*/
-*/
+void
-void
+VMS__start_the_work_then_wait_until_done()
-VMS__start()
 { int coreIdx;
+//Start the core loops running
-//TODO: Save "orig" stack pointer and frame ptr -- restore in VMS__end()
+//===========================================================================
-//Create the win threads that animate the core loops
+LARGE_INTEGER stPerfCount, endPerfCount, countFreq;
+unsigned long long count = 0, freq = 0;
+double runTime;
+QueryPerformanceCounter( &stPerfCount );
+//start them running
+for( coreIdx=0; coreIdx < NUM_CORES; coreIdx++ )
+{    //Create the threads
+ResumeThread( coreLoopThdHandles[coreIdx] ); //starts thread
+}
+//wait for all to complete
 for( coreIdx=0; coreIdx < NUM_CORES; coreIdx++ )
 {
-coreLoopThdParams[coreIdx] = (ThdParams *)malloc( sizeof(ThdParams) );
+WaitForSingleObject(coreLoopThdHandles[coreIdx], INFINITE);
-coreLoopThdParams[coreIdx]->coreNum = coreIdx;
-coreLoopThdHandles[coreIdx] =
-CreateThread ( NULL, // Security attributes
-0, // Stack size
-coreLoop,
-coreLoopThdParams[coreIdx],
-CREATE_SUSPENDED,
-&(coreLoopThdIds[coreIdx])
-);
-ResumeThread( coreLoopThdHandles[coreIdx] ); //starts thread
 }
+//NOTE: do not clean up VMS env here -- semantic layer has to have
+// a chance to clean up its environment first, then do a call to free
+// the Master env and rest of VMS locations
+QueryPerformanceCounter( &endPerfCount );
+count = endPerfCount.QuadPart - stPerfCount.QuadPart;
+QueryPerformanceFrequency( &countFreq );
+freq = countFreq.QuadPart;
+runTime = (double)count / (double)freq;
+printf("\n Time startup to shutdown: %f\n", runTime);
+fflush( stdin );
 }
 /*Create stack, then create __cdecl structure on it and put initialData and
 /*This inserts the semantic-layer's request data into standard VMS carrier
 */
 inline void
-VMS__send_sem_request( void *semReqData, VirtProcr *callingPr )
+VMS__add_sem_request( void *semReqData, VirtProcr *callingPr )
 { VMSReqst *req;
 req = malloc( sizeof(VMSReqst) );
 //   req->virtProcrFrom      = callingPr;
 req->reqType        = semantic;
 req->nextReqst      = callingPr->requests;
 callingPr->requests = req;
 }
-/*This creates a request of type "dissipate" -- which will cause the virt
-* processor's state and owned locations to be freed
-*/
-inline void
-VMS__send_dissipate_request( VirtProcr *procrToDissipate )
-{ VMSReqst *req;
-req = malloc( sizeof(VMSReqst) );
-//   req->virtProcrFrom      = callingPr;
-req->reqType               = dissipate;
-req->nextReqst             = procrToDissipate->requests;
-procrToDissipate->requests = req;
-}
 //TODO: add a semantic-layer supplied "freer" for the semantic-data portion
 // of a request -- IE call with both a virt procr and a fn-ptr to request
 // freer (or maybe put request freer as a field in virt procr?)
 void
 req = procrWithReq->requests;
 procrWithReq->requests = procrWithReq->requests->nextReqst;
 free( req );
 }
-/*This must be called by the request handler plugin -- it cannot be called
-* from the semantic library "dissipate processor" function -- instead, the
+//TODO: add a semantic-layer supplied "freer" for the semantic-data portion
-* semantic layer has to generate a request for the plug-in to call this
+// of a request -- IE call with both a virt procr and a fn-ptr to request
-* function.
+// freer (also maybe put sem request freer as a field in virt procr?)
-*The reason is that this frees the virtual processor's stack -- which is
+void
-* still in use inside semantic library calls!
+VMS__free_request( VMSReqst *req )
-*
+{
-*This frees or recycles all the state owned by and comprising the animating
+free( req );
-* virtual procr.  It frees any state that was malloc'd by the VMS system
+}
-* itself, and asks the VMS system to dis-own any VMS__malloc'd locations.
-*If the dissipated processor is the sole (remaining) owner of VMS__malloc'd
+VMSReqst *
-* state, then that state gets freed (or sent to recycling) as a side-effect
+VMS__take_top_request_from( VirtProcr *procrWithReq )
-* of dis-owning it.
+{ VMSReqst *req;
-*/
-void
+req = procrWithReq->requests;
-VMS__free_procr_locs( VirtProcr *animatingPr )
+if( req == NULL ) return req;
-{
-//dis-own all locations owned by this processor, causing to be freed
-// any locations that it is (was) sole owner of
-//TODO: implement VMS__malloc system, including "give up ownership"
-VMS__remove_and_free_top_request( animatingPr );
-free( animatingPr->startOfStack );
-//NOTE: animatingPr->semanticData should either have been allocated
+procrWithReq->requests = procrWithReq->requests->nextReqst;
-// with VMS__malloc, or else freed in the request handler plug-in.
+return req;
-//NOTE: initialData was given to the processor, so should either have
+}
-// been alloc'd with VMS__malloc, or freed by the level above animPr.
-//So, all that's left to free here is the VirtProcr struc itself
+inline int
-free( animatingPr );
+VMS__isSemanticReqst( VMSReqst *req )
+{
+return ( req->reqType == semantic );
+}
+inline void *
+VMS__take_sem_reqst_from( VMSReqst *req )
+{
+return req->semReqData;
+}
+inline int
+VMS__isDissipateReqst( VMSReqst *req )
+{
+return ( req->reqType == dissipate );
+}
+inline int
+VMS__isCreateReqst( VMSReqst *req )
+{
+return ( req->reqType == regCreated );
+}
+void
+VMS__send_register_new_procr_request(VirtProcr *newPr, VirtProcr *reqstingPr)
+{ VMSReqst *req;
+req                  = malloc( sizeof(VMSReqst) );
+req->reqType         = regCreated;
+req->semReqData      = newPr;
+req->nextReqst       = reqstingPr->requests;
+reqstingPr->requests = req;
+VMS__suspend_procr( reqstingPr );
 }
 /*The semantic layer figures out when the work is done ( perhaps by a call
 * in the application to "work all done", or perhaps all the virtual
 {
 return VMS__create_procr( &shutdownFn, NULL );
 }
+/*This must be called by the request handler plugin -- it cannot be called
+* from the semantic library "dissipate processor" function -- instead, the
+* semantic layer has to generate a request for the plug-in to call this
+* function.
+*The reason is that this frees the virtual processor's stack -- which is
+* still in use inside semantic library calls!
+*
+*This frees or recycles all the state owned by and comprising the VMS
+* portion of the animating virtual procr.  The request handler must first
+* free any semantic data created for the processor that didn't use the
+* VMS_malloc mechanism.  Then it calls this, which first asks the malloc
+* system to disown any state that did use VMS_malloc, and then frees the
+* statck and the processor-struct itself.
+*If the dissipated processor is the sole (remaining) owner of VMS__malloc'd
+* state, then that state gets freed (or sent to recycling) as a side-effect
+* of dis-owning it.
+*/
+void
+VMS__free_procr_locs( VirtProcr *animatingPr )
+{
+//dis-own all locations owned by this processor, causing to be freed
+// any locations that it is (was) sole owner of
+//TODO: implement VMS__malloc system, including "give up ownership"
+//The dissipate request might still be attached, so remove and free it
+VMS__remove_and_free_top_request( animatingPr );
+free( animatingPr->startOfStack );
+//NOTE: initialData was given to the processor, so should either have
+// been alloc'd with VMS__malloc, or freed by the level above animPr.
+//So, all that's left to free here is the stack and the VirtProcr struc
+// itself
+free( animatingPr->startOfStack );
+free( animatingPr );
+}
 /*This is the function run by the special "shut-down" processor
 *
 *The _VMSMasterEnv is needed by this shut down function, so the "wait"
 * function run in the main loop has to free it, and the thread-related
 * locations (coreLoopThdParams a.s.o.).
 //This is an issue: the animating processor of this function may not
 // get its request handled before all the cores have shutdown.
 //TODO: after all the threads stop, clean out the MasterEnv, the
 // SemanticEnv, and the workQ before returning.
-VMS__send_dissipate_request( animatingPr );
+VMS__dissipate_procr( animatingPr );  //will never come back from this
-VMS__suspend_procr( animatingPr );  //will never come back from this
+}
-}
+/*This has to free anything allocated during VMS_init, and any other alloc'd
+* locations that might be left over.
+*/
+void
+VMS__shutdown()
+{ int i;
+free( _VMSWorkQ );
+free( _VMSMasterEnv->filledSlots );
+for( i = 0; i < NUM_SCHED_SLOTS; i++ )
+{
+free( _VMSMasterEnv->schedSlots[i] );
+}
+free( _VMSMasterEnv->schedSlots);
+VMS__free_procr_locs( _VMSMasterEnv->masterVirtPr );
+free( _VMSMasterEnv );
+}
+//===========================================================================
 inline TSCount getTSCount()
 { unsigned int low, high;
 TSCount  out;

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

comparison VMS.c @ 24:2b161e1a50ee