VMS/VMS_Implementations/VMS_impls/VMS__MC_shared

comparison VMS.c @ 61:984f7d78bfdf

Merge See what happens -- merged test stuff into Nov 8 VMS version

author	SeanHalle
date	Thu, 11 Nov 2010 06:19:51 -0800
parents	054006c26b92 26d53313a8f2
children

comparison

equal deleted inserted replaced

-:12fa3731f956
+:a016209003e1
 * Licensed under BSD
 */
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <malloc.h>
+#include <sys/time.h>
 #include "VMS.h"
 #include "Queue_impl/BlockingQueue.h"
 #include "Histogram/Histogram.h"
 void
 create_masterEnv();
 void
 create_the_coreLoop_OS_threads();
+MallocProlog *
+create_free_list();
+void
+endOSThreadFn( void *initData, VirtProcr *animatingPr );
 pthread_mutex_t suspendLock = PTHREAD_MUTEX_INITIALIZER;
 pthread_cond_t  suspend_cond  = PTHREAD_COND_INITIALIZER;
 //===========================================================================
 { MasterEnv       *masterEnv;
 VMSQueueStruc **readyToAnimateQs;
 int              coreIdx;
 VirtProcr      **masterVPs;
 SchedSlot     ***allSchedSlots; //ptr to array of ptrs
 //Make the master env, which holds everything else
 _VMSMasterEnv = malloc( sizeof(MasterEnv) );
+//Very first thing put into the master env is the free-list, seeded
+// with a massive initial chunk of memory.
+//After this, all other mallocs are VMS__malloc.
+_VMSMasterEnv->freeListHead        = VMS_ext__create_free_list();
+//===================== Only VMS__malloc after this ====================
 masterEnv     = _VMSMasterEnv;
-//Need to set start pt here 'cause used by seed procr, which is created
-// before the first core loop starts up. -- not sure how yet..
-//   masterEnv->coreLoopStartPt = ;
-//   masterEnv->coreLoopEndPt   = ;
 //Make a readyToAnimateQ for each core loop
-readyToAnimateQs = malloc( NUM_CORES * sizeof(VMSQueueStruc *) );
+readyToAnimateQs = VMS__malloc( NUM_CORES * sizeof(VMSQueueStruc *) );
-masterVPs        = malloc( NUM_CORES * sizeof(VirtProcr *) );
+masterVPs        = VMS__malloc( NUM_CORES * sizeof(VirtProcr *) );
 //One array for each core, 3 in array, core's masterVP scheds all
-allSchedSlots    = malloc( NUM_CORES * sizeof(SchedSlot *) );
+allSchedSlots    = VMS__malloc( NUM_CORES * sizeof(SchedSlot *) );
+_VMSMasterEnv->numProcrsCreated = 0;  //used by create procr
 for( coreIdx = 0; coreIdx < NUM_CORES; coreIdx++ )
 {
-readyToAnimateQs[ coreIdx ] = makeSRSWQ();
+readyToAnimateQs[ coreIdx ] = makeVMSQ();
-//Q: should give masterVP core-specific into as its init data?
+//Q: should give masterVP core-specific info as its init data?
 masterVPs[ coreIdx ] = VMS__create_procr( &masterLoop, masterEnv );
 masterVPs[ coreIdx ]->coreAnimatedBy = coreIdx;
 allSchedSlots[ coreIdx ] = create_sched_slots(); //makes for one core
+_VMSMasterEnv->numMasterInARow[ coreIdx ] = 0;
+_VMSMasterEnv->workStealingGates[ coreIdx ] = NULL;
 }
 _VMSMasterEnv->readyToAnimateQs = readyToAnimateQs;
 _VMSMasterEnv->masterVPs        = masterVPs;
+_VMSMasterEnv->masterLock       = UNLOCKED;
 _VMSMasterEnv->allSchedSlots    = allSchedSlots;
+_VMSMasterEnv->workStealingLock = UNLOCKED;
 //============================= MEASUREMENT STUFF ========================
 #ifdef MEAS__TIME_MASTER
 _VMSMasterEnv->stats->masterTimeHist = makeHistogram( 25, 500,    800 );
 //Aug 19, 2010:  no longer need to place initial masterVP into queue
 // because coreLoop now controls -- animates its masterVP when no work
-//==================== malloc substitute ========================
+//============================= MEASUREMENT STUFF ========================
-//
+#ifdef STATS__TURN_ON_PROBES
-//Testing whether malloc is using thread-local storage and therefore
+_VMSMasterEnv->dynIntervalProbesInfo =
-// causing unreliable behavior.
+makePrivDynArrayOfSize( &(_VMSMasterEnv->intervalProbes), 200);
-//Just allocate a massive chunk of memory and roll own malloc/free and
-// make app use VMS__malloc_to, which will suspend and perform malloc
+_VMSMasterEnv->probeNameHashTbl = makeHashTable( 1000, &VMS__free );
-// in the master, taking from this massive chunk.
+//put creation time directly into master env, for fast retrieval
-//   initFreeList();
+struct timeval timeStamp;
+gettimeofday( &(timeStamp), NULL);
-}
+_VMSMasterEnv->createPtInSecs =
+timeStamp.tv_sec +(timeStamp.tv_usec/1000000.0);
-/*
+#endif
-void
+//========================================================================
-initMasterMalloc()
-{
+}
-_VMSMasterEnv->mallocChunk = malloc( MASSIVE_MALLOC_SIZE );
-//The free-list element is the first several locations of an
-// allocated chunk -- the address given to the application is pre-
-// pended with both the ownership structure and the free-list struc.
-//So, write the values of these into the first locations of
-// mallocChunk -- which marks it as free & puts in its size.
-listElem = (FreeListElem *)_VMSMasterEnv->mallocChunk;
-listElem->size = MASSIVE_MALLOC_SIZE - NUM_PREPEND_BYTES
-listElem->next = NULL;
-}
-void
-dissipateMasterMalloc()
-{
-//Just foo code -- to get going -- doing as if free list were link-list
-currElem = _VMSMasterEnv->freeList;
-while( currElem != NULL )
-{
-nextElem = currElem->next;
-masterFree( currElem );
-currElem = nextElem;
-}
-free( _VMSMasterEnv->freeList );
-}
-*/
 SchedSlot **
 create_sched_slots()
 { SchedSlot  **schedSlots;
 int i;
-schedSlots  = malloc( NUM_SCHED_SLOTS * sizeof(SchedSlot *) );
+schedSlots  = VMS__malloc( NUM_SCHED_SLOTS * sizeof(SchedSlot *) );
 for( i = 0; i < NUM_SCHED_SLOTS; i++ )
 {
-schedSlots[i] = malloc( sizeof(SchedSlot) );
+schedSlots[i] = VMS__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++ )
 {
-free( schedSlots[i] );
+VMS__free( schedSlots[i] );
 }
-free( schedSlots );
+VMS__free( schedSlots );
 }
 void
 create_the_coreLoop_OS_threads()
 {
 //========================================================================
 //                      Create the Threads
-int coreIdx, retCode, i;
+int coreIdx, retCode;
 //create the arrays used to measure TSC offsets between cores
 pongNums  = malloc( NUM_CORES * sizeof( int ) );
 pingTimes = malloc( NUM_CORES * NUM_TSC_ROUND_TRIPS * sizeof( TSCount ) );
 pongTimes = malloc( NUM_CORES * NUM_TSC_ROUND_TRIPS * sizeof( TSCount ) );
 // 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]          = malloc( sizeof(ThdParams) );
+{ coreLoopThdParams[coreIdx]          = VMS__malloc( sizeof(ThdParams) );
 coreLoopThdParams[coreIdx]->coreNum = coreIdx;
 retCode =
 pthread_create( &(coreLoopThdHandles[coreIdx]),
 thdAttrs,
 &coreLoop,
 (void *)(coreLoopThdParams[coreIdx]) );
-if(retCode){printf("ERROR creating thread: %d\n", retCode); exit(0);}
+if(retCode){printf("ERROR creating thread: %d\n", retCode); exit(1);}
 }
 }
 /*Semantic layer calls this when it want the system to start running..
 *
 * function call
 *No need to save registers on old stack frame, because there's no old
 * animator state to return to --
 *
 */
-VirtProcr *
+inline VirtProcr *
-VMS__create_procr( VirtProcrFnPtr fnPtr, void *initialData )
+create_procr_helper( VirtProcr *newPr,       VirtProcrFnPtr  fnPtr,
-{ VirtProcr *newPr;
+void      *initialData, char           *stackLocs )
-char      *stackLocs, *stackPtr;
+{
+char  *stackPtr;
 //============================= MEASUREMENT STUFF ========================
 #ifdef MEAS__TIME_MASTER
 int32 startStamp;
 saveLowTimeStampCountInto( startStamp );
 #endif
 //========================================================================
+newPr->startOfStack = stackLocs;
-newPr              = malloc( sizeof(VirtProcr) );
+newPr->procrID      = _VMSMasterEnv->numProcrsCreated++;
-newPr->procrID     = numProcrsCreated++;
+newPr->nextInstrPt  = fnPtr;
-newPr->nextInstrPt = fnPtr;
+newPr->initialData  = initialData;
-newPr->initialData = initialData;
+newPr->requests     = NULL;
-newPr->requests    = NULL;
+newPr->schedSlot    = NULL;
-newPr->schedSlot   = NULL;
-//   newPr->coreLoopStartPt = _VMSMasterEnv->coreLoopStartPt;
 //fnPtr takes two params -- void *initData & void *animProcr
 //alloc stack locations, make stackPtr be the highest addr minus room
 // for 2 params + return addr.  Return addr (NULL) is in loc pointed to
 // by stackPtr, initData at stackPtr + 4 bytes, animatingPr just above
-stackLocs = malloc( VIRT_PROCR_STACK_SIZE );
-if(stackLocs == 0) {perror("error: malloc stack"); exit(1);}
-newPr->startOfStack = stackLocs;
 stackPtr = ( (char *)stackLocs + VIRT_PROCR_STACK_SIZE - 0x10 );
 //setup __cdecl on stack -- coreloop will switch to stackPtr before jmp
 *( (int *)stackPtr + 2 ) = (int) newPr; //rightmost param -- 32bit pointer
 *( (int *)stackPtr + 1 ) = (int) initialData;  //next  param to left
 newPr->stackPtr = stackPtr; //core loop will switch to this, then
 newPr->framePtr = stackPtr; //suspend loop will save new stack & frame ptr
 #ifdef MEAS__TIME_MASTER
 int32 endStamp;
 saveLowTimeStampCountInto( endStamp );
 addIntervalToHist( startStamp, endStamp,
 _VMSMasterEnv->stats->createHist );
+//============================= MEASUREMENT STUFF ========================
+#ifdef STATS__TURN_ON_PROBES
+struct timeval timeStamp;
+gettimeofday( &(timeStamp), NULL);
+newPr->createPtInSecs = timeStamp.tv_sec +(timeStamp.tv_usec/1000000.0) -
+_VMSMasterEnv->createPtInSecs;
 #endif
 //========================================================================
 return newPr;
+}
+inline VirtProcr *
+VMS__create_procr( VirtProcrFnPtr fnPtr, void *initialData )
+{ VirtProcr *newPr;
+char      *stackLocs;
+newPr      = VMS__malloc( sizeof(VirtProcr) );
+stackLocs  = VMS__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 *
+VMS_ext__create_procr( VirtProcrFnPtr fnPtr, void *initialData )
+{ VirtProcr *newPr;
+char      *stackLocs;
+newPr      = malloc( sizeof(VirtProcr) );
+stackLocs  = malloc( VIRT_PROCR_STACK_SIZE );
+if( stackLocs == 0 )
+{ perror("malloc stack"); exit(1); }
+return create_procr_helper( newPr, fnPtr, initialData, stackLocs );
 }
 /*there is a label inside this function -- save the addr of this label in
 * the callingPr struc, as the pick-up point from which to start the next
 * there, and will get passed along, inside the request handler, to the
 * next work-unit for that procr.
 */
 void
 VMS__suspend_procr( VirtProcr *animatingPr )
-{ void *jmpPt, *stackPtrAddr, *framePtrAddr, *coreLoopStackPtr;
+{
-void *coreLoopFramePtr;
 //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
 // "return" from this call.
 animatingPr->nextInstrPt = &&ResumePt;
 //return ownership of the virt procr and sched slot to Master virt pr
 animatingPr->schedSlot->workIsDone = TRUE;
-//   coreIdx = callingPr->coreAnimatedBy;
-stackPtrAddr      = &(animatingPr->stackPtr);
-framePtrAddr      = &(animatingPr->framePtr);
-jmpPt             = _VMSMasterEnv->coreLoopStartPt;
-coreLoopFramePtr  = animatingPr->coreLoopFramePtr;//need this only
-coreLoopStackPtr  = animatingPr->coreLoopStackPtr;//safety
-//Save the virt procr's stack and frame ptrs,
-asm volatile("movl %0,     %%eax;  \
-movl %%esp, (%%eax); \
-movl %1,     %%eax;  \
-movl %%ebp, (%%eax) "\
-/* outputs */ : "=g" (stackPtrAddr), "=g" (framePtrAddr) \
-/* inputs  */ :        \
-/* clobber */ : "%eax" \
-);
 //===========================  Measurement stuff ========================
 #ifdef MEAS__TIME_STAMP_SUSP
 //record time stamp: compare to time-stamp recorded below
 saveLowTimeStampCountInto( animatingPr->preSuspTSCLow );
 #endif
 //=======================================================================
-//restore coreloop's frame ptr, then jump back to "start" of core loop
-//Note, GCC compiles to assembly that saves esp and ebp in the stack
+SwitchToCoreLoop( animatingPr )
-// frame -- so have to explicitly do assembly that saves to memory
-asm volatile("movl %0, %%eax;      \
+//=======================================================================
-movl %1, %%esp;      \
-movl %2, %%ebp;      \
-jmp  %%eax    "      \
-/* outputs */ :                    \
-/* inputs  */ : "m" (jmpPt), "m"(coreLoopStackPtr), "m"(coreLoopFramePtr)\
-/* clobber */ : "memory", "%eax", "%ebx", "%ecx", "%edx", "%edi","%esi"  \
-); //list everything as clobbered to force GCC to save all
-// live vars that are in regs on stack before this
-// assembly, so that stack pointer is correct, before jmp
 ResumePt:
 #ifdef MEAS__TIME_STAMP_SUSP
 //NOTE: only take low part of count -- do sanity check when take diff
 saveLowTimeStampCountInto( animatingPr->postSuspTSCLow );
 #endif
 return;
 }
+/*For this implementation of VMS, it may not make much sense to have the
+* system of requests for creating a new processor done this way.. but over
+* the scope of single-master, multi-master, mult-tasking, OS-implementing,
+* distributed-memory, and so on, this gives VMS implementation a chance to
+* do stuff before suspend, in the AppVP, and in the Master before the plugin
+* is called, as well as in the lang-lib before this is called, and in the
+* plugin.  So, this gives both VMS and language implementations a chance to
+* intercept at various points and do order-dependent stuff.
+*Having a standard VMSNewPrReqData struc allows the language to create 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 )
+{ VMSReqst req;
+req.reqType          = createReq;
+req.semReqData       = semReqData;
+req.nextReqst        = reqstingPr->requests;
+reqstingPr->requests = &req;
+VMS__suspend_procr( reqstingPr );
+}
 /*
 *This adds a request to dissipate, then suspends the processor so that the
 * request handler will receive the request.  The request handler is what
 * 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__dissipate_procr( VirtProcr *procrToDissipate )
+VMS__send_dissipate_req( VirtProcr *procrToDissipate )
+{ VMSReqst req;
+req.reqType                = dissipate;
+req.nextReqst              = procrToDissipate->requests;
+procrToDissipate->requests = &req;
+VMS__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 )
+{
+//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
+//Note, should not stack-allocate initial data -- no guarantee, in
+// general that creating processor will outlive ones it creates.
+free( procrToDissipate->startOfStack );
+free( procrToDissipate );
+}
+/*This call's name indicates that request is malloc'd -- so req handler
+* has to free any extra requests tacked on before a send, using this.
+*
+* This inserts the semantic-layer's request data into standard VMS carrier
+* request data-struct that is mallocd.  The sem request doesn't need to
+* be malloc'd if this is called inside the same call chain before the
+* 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,
+VirtProcr *callingPr )
 { VMSReqst *req;
-req = malloc( sizeof(VMSReqst) );
+req = VMS__malloc( sizeof(VMSReqst) );
-//   req->virtProcrFrom      = callingPr;
+req->reqType         = semantic;
-req->reqType               = dissipate;
+req->semReqData      = semReqData;
-req->nextReqst             = procrToDissipate->requests;
+req->nextReqst       = callingPr->requests;
-procrToDissipate->requests = req;
+callingPr->requests = req;
+}
-VMS__suspend_procr( procrToDissipate );
-}
 /*This inserts the semantic-layer's request data into standard VMS carrier
+* 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__add_sem_request( void *semReqData, VirtProcr *callingPr )
+VMS__send_sem_request( void *semReqData, VirtProcr *callingPr )
+{ VMSReqst req;
+req.reqType         = semantic;
+req.semReqData      = semReqData;
+req.nextReqst       = callingPr->requests;
+callingPr->requests = &req;
+VMS__suspend_procr( callingPr );
+}
+inline void
+VMS__send_VMSSem_request( void *semReqData, VirtProcr *callingPr )
+{ VMSReqst req;
+req.reqType         = VMSSemantic;
+req.semReqData      = semReqData;
+req.nextReqst       = callingPr->requests; //gab any other preceeding
+callingPr->requests = &req;
+VMS__suspend_procr( callingPr );
+}
+/*
+*/
+VMSReqst *
+VMS__take_next_request_out_of( VirtProcr *procrWithReq )
 { VMSReqst *req;
-req = malloc( sizeof(VMSReqst) );
-//   req->virtProcrFrom      = callingPr;
-req->reqType        = semantic;
-req->semReqData     = semReqData;
-req->nextReqst      = callingPr->requests;
-callingPr->requests = req;
-}
-/*Use this to get first request before starting request handler's loop
-*/
-VMSReqst *
-VMS__take_top_request_from( VirtProcr *procrWithReq )
-{ VMSReqst *req;
 req = procrWithReq->requests;
-if( req == NULL ) return req;
+if( req == NULL ) return NULL;
 procrWithReq->requests = procrWithReq->requests->nextReqst;
 return req;
 }
-/*A subtle bug due to freeing then accessing "next" after freed caused this
-* form of call to be put in -- so call this at end of request handler loop
-* that iterates through the requests.
-*/
-VMSReqst *
-VMS__free_top_and_give_next_request_from( VirtProcr *procrWithReq )
-{ VMSReqst *req;
-req = procrWithReq->requests;
-if( req == NULL ) return NULL;
-procrWithReq->requests = procrWithReq->requests->nextReqst;
-VMS__free_request( req );
-return procrWithReq->requests;
-}
-//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 (also maybe put sem request freer as a field in virt procr?)
-//MeasVMS relies right now on this only freeing VMS layer of request -- the
-// semantic portion of request is alloc'd and freed by request handler
-void
-VMS__free_request( VMSReqst *req )
-{
-free( req );
-}
-inline int
-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 )
-{
+/* This is for OS requests and VMS infrastructure requests, such as to create
-return ( req->reqType == dissipate );
+*  a probe -- a probe is inside the heart of VMS-core, it's not part of any
-}
+*  language -- but it's also a semantic thing that's triggered from and used
+*  in the application.. so it crosses abstractions..  so, need some special
-inline int
+*  pattern here for handling such requests.
-VMS__isCreateReqst( VMSReqst *req )
+* Doing this just like it were a second language sharing VMS-core.
-{
+*
-return ( req->reqType == regCreated );
+* This is called from the language's request handler when it sees a request
-}
+*  of type VMSSemReq
+*
-void
+* TODO: Later change this, to give probes their own separate plugin & have
-VMS__send_req_to_register_new_procr(VirtProcr *newPr, VirtProcr *reqstingPr)
+*  VMS-core steer the request to appropriate plugin
-{ VMSReqst *req;
+* Do the same for OS calls -- look later at it..
+*/
-req                  = malloc( sizeof(VMSReqst) );
+void inline
-req->reqType         = regCreated;
+VMS__handle_VMSSemReq( VMSReqst *req, VirtProcr *requestingPr, void *semEnv,
-req->semReqData      = newPr;
+ResumePrFnPtr resumePrFnPtr )
-req->nextReqst       = reqstingPr->requests;
+{ VMSSemReq     *semReq;
-reqstingPr->requests = req;
+IntervalProbe *newProbe;
+int32          nameLen;
-VMS__suspend_procr( reqstingPr );
+semReq = req->semReqData;
+newProbe          = VMS__malloc( sizeof(IntervalProbe) );
+nameLen = strlen( semReq->nameStr );
+newProbe->nameStr = VMS__malloc( nameLen );
+memcpy( newProbe->nameStr, semReq->nameStr, nameLen );
+newProbe->hist    = NULL;
+newProbe->schedChoiceWasRecorded = FALSE;
+//This runs in masterVP, so no race-condition worries
+newProbe->probeID =
+addToDynArray( newProbe, _VMSMasterEnv->dynIntervalProbesInfo );
+requestingPr->dataRetFromReq = newProbe;
+(*resumePrFnPtr)( requestingPr, semEnv );
 }
 /*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
+* semantic layer has to generate a request, and the plug-in calls 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
 *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__handle_dissipate_reqst( VirtProcr *animatingPr )
+VMS__dissipate_procr( 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__free_top_and_give_next_request_from( animatingPr );
 //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 );
+//Note, should not stack-allocate initial data -- no guarantee, in
-free( animatingPr );
+// general that creating processor will outlive ones it creates.
-}
+VMS__free( animatingPr->startOfStack );
+VMS__free( animatingPr );
+}
-//TODO: re-architect so that have clean separation between request handler
+//TODO: look at architecting cleanest separation between request handler
 // and master loop, for dissipate, create, shutdown, and other non-semantic
 // requests.  Issue is chain: one removes requests from AppVP, one dispatches
 // on type of request, and one handles each type..  but some types require
 // action from both request handler and master loop -- maybe just give the
 // request handler calls like:  VMS__handle_X_request_type
-void
-endOSThreadFn( void *initData, VirtProcr *animatingPr );
 /*This is called by the semantic layer's request handler when it decides its
 * time to shut down the VMS system.  Calling this causes the core loop OS
 * threads to exit, which unblocks the entry-point function that started up
 * VMS, and allows it to grab the result and return to the original single-
 * and-wait function has to free a bunch of stuff after it detects the
 * threads have all died: the masterEnv, the thread-related locations,
 * masterVP any AppVPs that might still be allocated and sitting in the
 * semantic environment, or have been orphaned in the _VMSWorkQ.
 *
-*NOTE: the semantic plug-in is expected to use VMS__malloc_to to get all the
+*NOTE: the semantic plug-in is expected to use VMS__malloc to get all the
 * locations it needs, and give ownership to masterVP.  Then, they will be
-* automatically freed when the masterVP is dissipated.  (This happens after
+* automatically freed.
-* the core loop threads have all exited)
 *
 *In here,create one core-loop shut-down processor for each core loop and put
 * them all directly into the readyToAnimateQ.
 *Note, this function can ONLY be called after the semantic environment no
 * longer cares if AppVPs get animated after the point this is called.  In
 * 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__handle_shutdown_reqst( void *dummy, VirtProcr *animatingPr )
+VMS__shutdown()
 { int coreIdx;
 VirtProcr *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 );
-writeSRSWQ( shutDownPr, _VMSMasterEnv->readyToAnimateQs[coreIdx] );
+writeVMSQ( shutDownPr, _VMSMasterEnv->readyToAnimateQs[coreIdx] );
 }
 }
 /* clobber */ : "memory", "%eax", "%ebx", "%ecx", "%edx", "%edi","%esi"  \
 );
 }
-/*This is called after the threads have shut down and control has returned
+/*This is called from the startup & shutdown
-* to the semantic layer, in the entry point function in the main thread.
+*/
-* It has to free anything allocated during VMS_init, and any other alloc'd
+void
-* locations that might be left over.
+VMS__cleanup_at_end_of_shutdown()
-*/
-void
-VMS__cleanup_after_shutdown()
 {
 VMSQueueStruc **readyToAnimateQs;
 int              coreIdx;
 VirtProcr      **masterVPs;
 SchedSlot     ***allSchedSlots; //ptr to array of ptrs
+//All the environment data has been allocated with VMS__malloc, so just
+// free its internal big-chunk and all inside it disappear.
+/*
 readyToAnimateQs = _VMSMasterEnv->readyToAnimateQs;
 masterVPs        = _VMSMasterEnv->masterVPs;
 allSchedSlots    = _VMSMasterEnv->allSchedSlots;
 for( coreIdx = 0; coreIdx < NUM_CORES; coreIdx++ )
 {
-freeSRSWQ( readyToAnimateQs[ coreIdx ] );
+freeVMSQ( readyToAnimateQs[ coreIdx ] );
+//master VPs were created external to VMS, so use external free
-VMS__handle_dissipate_reqst( masterVPs[ coreIdx ] );
+VMS__dissipate_procr( masterVPs[ coreIdx ] );
 freeSchedSlots( allSchedSlots[ coreIdx ] );
 }
-free( _VMSMasterEnv->readyToAnimateQs );
+VMS__free( _VMSMasterEnv->readyToAnimateQs );
-free( _VMSMasterEnv->masterVPs );
+VMS__free( _VMSMasterEnv->masterVPs );
-free( _VMSMasterEnv->allSchedSlots );
+VMS__free( _VMSMasterEnv->allSchedSlots );
-free( _VMSMasterEnv );
+//============================= MEASUREMENT STUFF ========================
-}
+#ifdef STATS__TURN_ON_PROBES
+freeDynArrayDeep( _VMSMasterEnv->dynIntervalProbesInfo, &VMS__free_probe);
+#endif
-//===========================================================================
+//========================================================================
+*/
-inline TSCount getTSC()
+//These are the only two that use system free
-{ unsigned int low, high;
+VMS_ext__free_free_list( _VMSMasterEnv->freeListHead );
-TSCount  out;
+free( (void *)_VMSMasterEnv );
+}
-saveTimeStampCountInto( low, high );
-out = high;
-out = (out << 32) + low;
+//================================
-return out;
-}
+/*Later, improve this -- for now, just exits the application after printing
+* the error message.
+*/
+void
+VMS__throw_exception( char *msgStr, VirtProcr *reqstPr, VMSExcp *excpData )
+{
+printf(msgStr);
+fflush(stdin);
+exit(1);
+}

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

comparison VMS.c @ 61:984f7d78bfdf