VMS/VMS_Implementations/VMS_impls/VMS__MC_shared

comparison VMS.c @ 205:cb888346c3e0

Changed include paths, but version still does not work because of accidental merge

author	Merten Sach <msach@mailbox.tu-berlin.de>
date	Fri, 17 Feb 2012 18:28:59 +0100
parents	ad8213a8e916
children

comparison

equal deleted inserted replaced

-:c13e3563523b
+:56f83c07959d
 #include <inttypes.h>
 #include <sys/time.h>
 #include "VMS.h"
 #include "ProcrContext.h"
-#include "Queue_impl/BlockingQueue.h"
-#include "Histogram/Histogram.h"
 #define thdAttrs NULL
 //===========================================================================
 void
-shutdownFn( void *dummy, VirtProcr *dummy2 );
+shutdownFn( void *dummy, SlaveVP *dummy2 );
 SchedSlot **
 create_sched_slots();
 void
 MallocProlog *
 create_free_list();
 void
-endOSThreadFn( void *initData, VirtProcr *animatingPr );
+endOSThreadFn( void *initData, SlaveVP *animatingPr );
 pthread_mutex_t suspendLock = PTHREAD_MUTEX_INITIALIZER;
 pthread_cond_t  suspend_cond  = PTHREAD_COND_INITIALIZER;
 //===========================================================================
 /*This allocates VMS data structures, populates the master VMSProc,
 * and master environment, and returns the master environment to the semantic
 * layer.
 */
 void
-VMS__init()
+VMS_int__init()
 {
 create_masterEnv();
 create_the_coreLoop_OS_threads();
 }
 #ifdef SEQUENTIAL
 /*To initialize the sequential version, just don't create the threads
 */
 void
-VMS__init_Seq()
+VMS_int__init_Seq()
 {
 create_masterEnv();
 }
 #endif
 void
 create_masterEnv()
 { MasterEnv       *masterEnv;
 VMSQueueStruc **readyToAnimateQs;
 int              coreIdx;
-VirtProcr      **masterVPs;
+SlaveVP      **masterVPs;
 SchedSlot     ***allSchedSlots; //ptr to array of ptrs
 //Make the master env, which holds everything else
 _VMSMasterEnv = malloc( sizeof(MasterEnv) );
 //===================== Only VMS__malloc after this ====================
 masterEnv     = (MasterEnv*)_VMSMasterEnv;
 //Make a readyToAnimateQ for each core loop
-readyToAnimateQs = VMS__malloc( NUM_CORES * sizeof(VMSQueueStruc *) );
+readyToAnimateQs = VMS_int__malloc( NUM_CORES * sizeof(VMSQueueStruc *) );
-masterVPs        = VMS__malloc( NUM_CORES * sizeof(VirtProcr *) );
+masterVPs        = VMS_int__malloc( NUM_CORES * sizeof(SlaveVP *) );
 //One array for each core, 3 in array, core's masterVP scheds all
-allSchedSlots    = VMS__malloc( NUM_CORES * sizeof(SchedSlot *) );
+allSchedSlots    = VMS_int__malloc( NUM_CORES * sizeof(SchedSlot *) );
-_VMSMasterEnv->numProcrsCreated = 0;  //used by create procr
+_VMSMasterEnv->numVPsCreated = 0;  //used by create procr
 for( coreIdx = 0; coreIdx < NUM_CORES; coreIdx++ )
 {
 readyToAnimateQs[ coreIdx ] = makeVMSQ();
 //Q: should give masterVP core-specific info as its init data?
-masterVPs[ coreIdx ] = VMS__create_procr( (VirtProcrFnPtr)&masterLoop, (void*)masterEnv );
+masterVPs[ coreIdx ] = VMS_int__create_procr( (VirtProcrFnPtr)&masterLoop, (void*)masterEnv );
 masterVPs[ coreIdx ]->coreAnimatedBy = coreIdx;
 allSchedSlots[ coreIdx ] = create_sched_slots(); //makes for one core
 _VMSMasterEnv->numMasterInARow[ coreIdx ] = 0;
 _VMSMasterEnv->workStealingGates[ coreIdx ] = NULL;
 }
 //============================= MEASUREMENT STUFF ========================
 #ifdef STATS__TURN_ON_PROBES
 _VMSMasterEnv->dynIntervalProbesInfo =
 makePrivDynArrayOfSize( (void***)&(_VMSMasterEnv->intervalProbes), 200);
-_VMSMasterEnv->probeNameHashTbl = makeHashTable( 1000, &VMS__free );
+_VMSMasterEnv->probeNameHashTbl = makeHashTable( 1000, &VMS_int__free );
 //put creation time directly into master env, for fast retrieval
 struct timeval timeStamp;
 gettimeofday( &(timeStamp), NULL);
 _VMSMasterEnv->createPtInSecs =
 SchedSlot **
 create_sched_slots()
 { SchedSlot  **schedSlots;
 int i;
-schedSlots  = VMS__malloc( NUM_SCHED_SLOTS * sizeof(SchedSlot *) );
+schedSlots  = VMS_int__malloc( NUM_SCHED_SLOTS * sizeof(SchedSlot *) );
 for( i = 0; i < NUM_SCHED_SLOTS; i++ )
 {
-schedSlots[i] = VMS__malloc( sizeof(SchedSlot) );
+schedSlots[i] = VMS_int__malloc( sizeof(SchedSlot) );
 //Set state to mean "handling requests done, slot needs filling"
 schedSlots[i]->workIsDone         = FALSE;
 schedSlots[i]->needsProcrAssigned = TRUE;
 }
 void
 freeSchedSlots( SchedSlot **schedSlots )
 { int i;
 for( i = 0; i < NUM_SCHED_SLOTS; i++ )
 {
-VMS__free( schedSlots[i] );
+VMS_int__free( schedSlots[i] );
 }
-VMS__free( schedSlots );
+VMS_int__free( schedSlots );
 }
 void
 create_the_coreLoop_OS_threads()
 // stuff before the coreLoops set off.
 _VMSMasterEnv->setupComplete = 0;
 //Make the threads that animate the core loops
 for( coreIdx=0; coreIdx < NUM_CORES; coreIdx++ )
-{ coreLoopThdParams[coreIdx]          = VMS__malloc( sizeof(ThdParams) );
+{ coreLoopThdParams[coreIdx]          = VMS_int__malloc( sizeof(ThdParams) );
 coreLoopThdParams[coreIdx]->coreNum = coreIdx;
 retCode =
 pthread_create( &(coreLoopThdHandles[coreIdx]),
 thdAttrs,
 /*Semantic layer calls this when it want the system to start running..
 *
 *This starts the core loops running then waits for them to exit.
 */
 void
-VMS__start_the_work_then_wait_until_done()
+VMS_WL__start_the_work_then_wait_until_done()
 { int coreIdx;
 //Start the core loops running
 //tell the core loop threads that setup is complete
 //get lock, to lock out any threads still starting up -- they'll see
 #ifdef SEQUENTIAL
 /*Only difference between version with an OS thread pinned to each core and
 * the sequential version of VMS is VMS__init_Seq, this, and coreLoop_Seq.
 */
 void
-VMS__start_the_work_then_wait_until_done_Seq()
+VMS_WL__start_the_work_then_wait_until_done_Seq()
 {
 //Instead of un-suspending threads, just call the one and only
 // core loop (sequential version), in the main thread.
 coreLoop_Seq( NULL );
 flushRegisters();
 }
 #endif
-inline VirtProcr *
+inline SlaveVP *
-VMS__create_procr( VirtProcrFnPtr fnPtr, void *initialData )
+VMS_int__create_procr( VirtProcrFnPtr fnPtr, void *initialData )
-{ VirtProcr *newPr;
+{ SlaveVP *newPr;
 void      *stackLocs;
-newPr      = VMS__malloc( sizeof(VirtProcr) );
+newPr      = VMS_int__malloc( sizeof(SlaveVP) );
-stackLocs  = VMS__malloc( VIRT_PROCR_STACK_SIZE );
+stackLocs  = VMS_int__malloc( VIRT_PROCR_STACK_SIZE );
 if( stackLocs == 0 )
 { perror("VMS__malloc stack"); exit(1); }
 return create_procr_helper( newPr, fnPtr, initialData, stackLocs );
 }
 /* "ext" designates that it's for use outside the VMS system -- should only
 * be called from main thread or other thread -- never from code animated by
 * a VMS virtual processor.
 */
-inline VirtProcr *
+inline SlaveVP *
 VMS_ext__create_procr( VirtProcrFnPtr fnPtr, void *initialData )
-{ VirtProcr *newPr;
+{ SlaveVP *newPr;
 char      *stackLocs;
-newPr      = malloc( sizeof(VirtProcr) );
+newPr      = malloc( sizeof(SlaveVP) );
 stackLocs  = malloc( VIRT_PROCR_STACK_SIZE );
 if( stackLocs == 0 )
 { perror("malloc stack"); exit(1); }
 return create_procr_helper( newPr, fnPtr, initialData, stackLocs );
 /*Anticipating multi-tasking
 */
 void *
-VMS__give_sem_env_for( VirtProcr *animPr )
+VMS_WL__give_sem_env_for( SlaveVP *animPr )
 {
 return _VMSMasterEnv->semanticEnv;
 }
 //===========================================================================
 /*there is a label inside this function -- save the addr of this label in
 * slave that animated the just-ended work-unit, so all the state is saved
 * there, and will get passed along, inside the request handler, to the
 * next work-unit for that procr.
 */
 void
-VMS__suspend_procr( VirtProcr *animatingPr )
+VMS_int__suspend_procr( SlaveVP *animatingPr )
 {
 //The request to master will cause this suspended virt procr to get
 // scheduled again at some future point -- to resume, core loop jumps
 // to the resume point (below), which causes restore of saved regs and
 * free the struc, while VMS knows how to get the newPr if it wants it, and
 * it lets the lang have lang-specific data related to creation transported
 * to the plugin.
 */
 void
-VMS__send_create_procr_req( void *semReqData, VirtProcr *reqstingPr )
+VMS_WL__send_create_procr_req( void *semReqData, SlaveVP *reqstingPr )
 { VMSReqst req;
 req.reqType          = createReq;
 req.semReqData       = semReqData;
 req.nextReqst        = reqstingPr->requests;
 reqstingPr->requests = &req;
-VMS__suspend_procr( reqstingPr );
+VMS_int__suspend_procr( reqstingPr );
 }
 /*
 *This adds a request to dissipate, then suspends the processor so that the
 * never returns from this call, but instead the virtual processor's trace
 * gets suspended in this call and all the virt processor's state disap-
 * pears -- making that suspend the last thing in the virt procr's trace.
 */
 void
-VMS__send_dissipate_req( VirtProcr *procrToDissipate )
+VMS_WL__send_dissipate_req( SlaveVP *procrToDissipate )
 { VMSReqst req;
 req.reqType                = dissipate;
 req.nextReqst              = procrToDissipate->requests;
 procrToDissipate->requests = &req;
-VMS__suspend_procr( procrToDissipate );
+VMS_int__suspend_procr( procrToDissipate );
 }
 /* "ext" designates that it's for use outside the VMS system -- should only
 * be called from main thread or other thread -- never from code animated by
 * a VMS virtual processor.
 *
 *Use this version to dissipate VPs created outside the VMS system.
 */
 void
-VMS_ext__dissipate_procr( VirtProcr *procrToDissipate )
+VMS_ext__dissipate_procr( SlaveVP *procrToDissipate )
 {
 //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
 * send of the last request is called.
 *
 *The request handler has to call VMS__free_VMSReq for any of these
 */
 inline void
-VMS__add_sem_request_in_mallocd_VMSReqst( void *semReqData,
+VMS_WL__add_sem_request_in_mallocd_VMSReqst( void *semReqData,
-VirtProcr *callingPr )
+SlaveVP *callingPr )
 { VMSReqst *req;
-req = VMS__malloc( sizeof(VMSReqst) );
+req = VMS_int__malloc( sizeof(VMSReqst) );
 req->reqType         = semantic;
 req->semReqData      = semReqData;
 req->nextReqst       = callingPr->requests;
 callingPr->requests = req;
 }
 * request data-struct is allocated on stack of this call & ptr to it sent
 * to plugin
 *Then it does suspend, to cause request to be sent.
 */
 inline void
-VMS__send_sem_request( void *semReqData, VirtProcr *callingPr )
+VMS_WL__send_sem_request( void *semReqData, SlaveVP *callingPr )
 { VMSReqst req;
 req.reqType         = semantic;
 req.semReqData      = semReqData;
 req.nextReqst       = callingPr->requests;
 callingPr->requests = &req;
-VMS__suspend_procr( callingPr );
+VMS_int__suspend_procr( callingPr );
 }
 inline void
-VMS__send_VMSSem_request( void *semReqData, VirtProcr *callingPr )
+VMS_WL__send_VMSSem_request( void *semReqData, SlaveVP *callingPr )
 { VMSReqst req;
 req.reqType         = VMSSemantic;
 req.semReqData      = semReqData;
 req.nextReqst       = callingPr->requests; //gab any other preceeding
 callingPr->requests = &req;
-VMS__suspend_procr( callingPr );
+VMS_int__suspend_procr( callingPr );
 }
 /*
 */
 VMSReqst *
-VMS__take_next_request_out_of( VirtProcr *procrWithReq )
+VMS_PI__take_next_request_out_of( SlaveVP *procrWithReq )
 { VMSReqst *req;
 req = procrWithReq->requests;
 if( req == NULL ) return NULL;
 return req;
 }
 inline void *
-VMS__take_sem_reqst_from( VMSReqst *req )
+VMS_PI__take_sem_reqst_from( VMSReqst *req )
 {
 return req->semReqData;
 }
 * TODO: Later change this, to give probes their own separate plugin & have
 *  VMS-core steer the request to appropriate plugin
 * Do the same for OS calls -- look later at it..
 */
 void inline
-VMS__handle_VMSSemReq( VMSReqst *req, VirtProcr *requestingPr, void *semEnv,
+VMS_PI__handle_VMSSemReq( VMSReqst *req, SlaveVP *requestingPr, void *semEnv,
-ResumePrFnPtr resumePrFnPtr )
+ResumeVPFnPtr resumePrFnPtr )
 { VMSSemReq     *semReq;
 IntervalProbe *newProbe;
 semReq = req->semReqData;
-newProbe          = VMS__malloc( sizeof(IntervalProbe) );
+newProbe          = VMS_int__malloc( sizeof(IntervalProbe) );
-newProbe->nameStr = VMS__strDup( semReq->nameStr );
+newProbe->nameStr = VMS_int__strDup( semReq->nameStr );
 newProbe->hist    = NULL;
 newProbe->schedChoiceWasRecorded = FALSE;
 //This runs in masterVP, so no race-condition worries
 newProbe->probeID =
 *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__dissipate_procr( VirtProcr *animatingPr )
+VMS_int__dissipate_procr( SlaveVP *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"
 // 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
 //Note, should not stack-allocate initial data -- no guarantee, in
 // general that creating processor will outlive ones it creates.
-VMS__free( animatingPr->startOfStack );
+VMS_int__free( animatingPr->startOfStack );
-VMS__free( animatingPr );
+VMS_int__free( animatingPr );
 }
 //TODO: look at architecting cleanest separation between request handler
 // and master loop, for dissipate, create, shutdown, and other non-semantic
 * other words, this can be used as an abort, or else it should only be
 * called when all AppVPs have finished dissipate requests -- only at that
 * point is it sure that all results have completed.
 */
 void
-VMS__shutdown()
+VMS_int__shutdown()
 { int coreIdx;
-VirtProcr *shutDownPr;
+SlaveVP *shutDownPr;
 //create the shutdown processors, one for each core loop -- put them
 // directly into the Q -- each core will die when gets one
 for( coreIdx=0; coreIdx < NUM_CORES; coreIdx++ )
 {    //Note, this is running in the master
-shutDownPr = VMS__create_procr( &endOSThreadFn, NULL );
+shutDownPr = VMS_int__create_procr( &endOSThreadFn, NULL );
 writeVMSQ( shutDownPr, _VMSMasterEnv->readyToAnimateQs[coreIdx] );
 }
 }
 * animator of the AppVP that is in turn animating this function over
 * to core loop function -- note that this slices out a level of virtual
 * processors).
 */
 void
-endOSThreadFn( void *initData, VirtProcr *animatingPr )
+endOSThreadFn( void *initData, SlaveVP *animatingPr )
 {
 #ifdef SEQUENTIAL
 asmTerminateCoreLoopSeq(animatingPr);
 #else
 asmTerminateCoreLoop(animatingPr);
 /*This is called from the startup & shutdown
 */
 void
-VMS__cleanup_at_end_of_shutdown()
+VMS_int__cleanup_at_end_of_shutdown()
 {
 //unused
 //VMSQueueStruc **readyToAnimateQs;
 //int              coreIdx;
 //VirtProcr      **masterVPs;
 printHist( _VMSMasterEnv->pluginTimeHist );
 for( coreIdx = 0; coreIdx < NUM_CORES; coreIdx++ )
 {
 freeVMSQ( readyToAnimateQs[ coreIdx ] );
 //master VPs were created external to VMS, so use external free
-VMS__dissipate_procr( masterVPs[ coreIdx ] );
+VMS_int__dissipate_procr( masterVPs[ coreIdx ] );
 freeSchedSlots( allSchedSlots[ coreIdx ] );
 }
 #endif
 #ifdef MEAS__TIME_STAMP_SUSP
 printHist( _VMSMasterEnv->pluginTimeHist );
 for( coreIdx = 0; coreIdx < NUM_CORES; coreIdx++ )
 {
 freeVMSQ( readyToAnimateQs[ coreIdx ] );
 //master VPs were created external to VMS, so use external free
-VMS__dissipate_procr( masterVPs[ coreIdx ] );
+VMS_int__dissipate_procr( masterVPs[ coreIdx ] );
 freeSchedSlots( allSchedSlots[ coreIdx ] );
 }
 #endif
 /*Later, improve this -- for now, just exits the application after printing
 * the error message.
 */
 void
-VMS__throw_exception( char *msgStr, VirtProcr *reqstPr, VMSExcp *excpData )
+VMS_PI__throw_exception( char *msgStr, SlaveVP *reqstPr, VMSExcp *excpData )
 {
 printf("%s",msgStr);
 fflush(stdin);
 exit(1);
 }

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

comparison VMS.c @ 205:cb888346c3e0