VMS/VMS_Implementations/VMS_impls/VMS__MC_shared

comparison VMS.c @ 50:8f7141a9272e

Added VMS__malloc and probes, and major re-factoring to separate mallocs

author	Me
date	Sat, 30 Oct 2010 20:54:36 -0700
parents	cf3e9238aeb0
children	f59cfa31a579

comparison

equal deleted inserted replaced

-:aa82127c7e20
+:e38566a22f76
 * 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();
 pthread_mutex_t suspendLock = PTHREAD_MUTEX_INITIALIZER;
 pthread_cond_t  suspend_cond  = PTHREAD_COND_INITIALIZER;
 //===========================================================================
 //One array for each core, 3 in array, core's masterVP scheds all
 allSchedSlots    = malloc( NUM_CORES * sizeof(SchedSlot *) );
 for( coreIdx = 0; coreIdx < NUM_CORES; coreIdx++ )
-{
+{    //running in main thread -- normal malloc inside makeSRSWQ
 readyToAnimateQs[ coreIdx ] = makeSRSWQ();
-//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 ] = VMS_ext__create_procr( &masterLoop, masterEnv );
 masterVPs[ coreIdx ]->coreAnimatedBy = coreIdx;
 allSchedSlots[ coreIdx ] = create_sched_slots(); //makes for one core
+_VMSMasterEnv->numMasterInARow[ coreIdx ] = FALSE;
 }
 _VMSMasterEnv->readyToAnimateQs = readyToAnimateQs;
 _VMSMasterEnv->masterVPs        = masterVPs;
+_VMSMasterEnv->masterLock       = UNLOCKED;
 _VMSMasterEnv->allSchedSlots    = allSchedSlots;
+_VMSMasterEnv->numProcrsCreated = 0;
 //Aug 19, 2010:  no longer need to place initial masterVP into queue
 // because coreLoop now controls -- animates its masterVP when no work
+_VMSMasterEnv->freeListHead        = VMS__create_free_list();
-//==================== malloc substitute ========================
+_VMSMasterEnv->amtOfOutstandingMem = 0; //none allocated yet
-//
-//Testing whether malloc is using thread-local storage and therefore
+//============================= MEASUREMENT STUFF ========================
-// causing unreliable behavior.
+#ifdef STATS__TURN_ON_PROBES
-//Just allocate a massive chunk of memory and roll own malloc/free and
+//creates intervalProbes array and sets pointer to it in masterEnv too
-// make app use VMS__malloc_to, which will suspend and perform malloc
+_VMSMasterEnv->dynIntervalProbesInfo =
-// in the master, taking from this massive chunk.
+makeDynArrayOfSize( &(_VMSMasterEnv->intervalProbes), 20 );
-//   initFreeList();
+_VMSMasterEnv->probeNameHashTbl = makeHashTable( 1000, NULL );
+_VMSMasterEnv->masterCreateProbeID =
-}
+VMS_ext__record_time_point_into_new_probe( "masterCreateProbe" );
+//Also put creation time directly into master env, for fast retrieval
-/*
+struct timeval timeStamp;
-void
+gettimeofday( &(timeStamp), NULL);
-initMasterMalloc()
+_VMSMasterEnv->createPtInSecs =
-{
+timeStamp.tv_sec +(timeStamp.tv_usec/1000000.0);
-_VMSMasterEnv->mallocChunk = malloc( MASSIVE_MALLOC_SIZE );
+#endif
+//========================================================================
-//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;
 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..
 *
 */
 void
 VMS__start_the_work_then_wait_until_done()
 { int coreIdx;
 //Start the core loops running
-//===========================================================================
-TSCount  startCount, endCount;
-unsigned long long count = 0, freq = 0;
-double   runTime;
-startCount = getTSCount();
 //tell the core loop threads that setup is complete
 //get lock, to lock out any threads still starting up -- they'll see
 // that setupComplete is true before entering while loop, and so never
 // wait on the condition
 }
 //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
-endCount = getTSCount();
-count = endCount - startCount;
-runTime = (double)count / (double)TSCOUNT_FREQ;
-printf("\n Time startup to shutdown: %f\n", runTime); fflush( stdin );
 }
 /*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.
 */
 * 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;
-newPr              = malloc( sizeof(VirtProcr) );
-newPr->procrID     = numProcrsCreated++;
+newPr->procrID     = _VMSMasterEnv->numProcrsCreated++;
 newPr->nextInstrPt = fnPtr;
 newPr->initialData = initialData;
 newPr->requests    = 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("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
+//============================= MEASUREMENT STUFF ========================
+#ifdef STATS__TURN_ON_PROBES
+struct timeval timeStamp;
+gettimeofday( &(timeStamp), NULL);
+newPr->createPtInSecs = timeStamp.tv_sec +(timeStamp.tv_usec/1000000.0);
+#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); }
+newPr->startOfStack = stackLocs;
+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); }
+newPr->startOfStack = stackLocs;
+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
 // "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;
 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
 * does the work of freeing memory and removing the processor from the
 * 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 )
-{ VMSReqst *req;
+{ VMSReqst req;
-req = malloc( sizeof(VMSReqst) );
+req.reqType                = dissipate;
-//   req->virtProcrFrom      = callingPr;
+req.nextReqst              = procrToDissipate->requests;
-req->reqType               = dissipate;
+procrToDissipate->requests = &req;
-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 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
 */
 inline void
 VMS__add_sem_request( void *semReqData, VirtProcr *callingPr )
+{ VMSReqst req;
+req.reqType         = semantic;
+req.semReqData      = semReqData;
+req.nextReqst       = callingPr->requests;
+callingPr->requests = &req;
+}
+/*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__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 )
+* This is called from the language's request handler when it sees a request
-{
+*  of type VMSSemReq
-return ( req->reqType == regCreated );
+*/
-}
+void inline
+VMS__handle_VMSSemReq( VMSReqst *req, VirtProcr *requestingPr, void *semEnv,
-void
+ResumePrFnPtr resumePrFnPtr )
-VMS__send_req_to_register_new_procr(VirtProcr *newPr, VirtProcr *reqstingPr)
+{ VMSSemReq     *semReq;
-{ VMSReqst *req;
+IntervalProbe *newProbe;
+int32          nameLen;
-req                  = malloc( sizeof(VMSReqst) );
-req->reqType         = regCreated;
+semReq = req->semReqData;
-req->semReqData      = newPr;
-req->nextReqst       = reqstingPr->requests;
+newProbe          = VMS__malloc( sizeof(IntervalProbe) );
-reqstingPr->requests = req;
+nameLen = strlen( semReq->nameStr );
+newProbe->nameStr = VMS__malloc( nameLen );
-VMS__suspend_procr( reqstingPr );
+memcpy( newProbe->nameStr, semReq->nameStr, nameLen );
+newProbe->hist    = NULL;
+newProbe->schedChoiceWasRecorded = FALSE;
+newProbe->probeID =
+addToDynArray( newProbe, _VMSMasterEnv->dynIntervalProbesInfo );
+requestingPr->dataReturnedFromReq = 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
 {
 //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
 // and master loop, for dissipate, create, shutdown, and other non-semantic
 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] );
 }
 }
 allSchedSlots    = _VMSMasterEnv->allSchedSlots;
 for( coreIdx = 0; coreIdx < NUM_CORES; coreIdx++ )
 {
 freeSRSWQ( readyToAnimateQs[ coreIdx ] );
+//master VPs were created external to VMS, so use external free
-VMS__handle_dissipate_reqst( masterVPs[ coreIdx ] );
+VMS_ext__dissipate_procr( masterVPs[ coreIdx ] );
 freeSchedSlots( allSchedSlots[ coreIdx ] );
 }
 free( _VMSMasterEnv->readyToAnimateQs );
 free( _VMSMasterEnv->masterVPs );
 free( _VMSMasterEnv->allSchedSlots );
+VMS_ext__free_free_list( _VMSMasterEnv->freeListHead );
+//============================= MEASUREMENT STUFF ========================
+#ifdef STATS__TURN_ON_PROBES
+freeDynArrayDeep( _VMSMasterEnv->dynIntervalProbesInfo, &free );
+#endif
+//========================================================================
 free( _VMSMasterEnv );
 }
-//===========================================================================
-inline TSCount getTSCount()
-{ unsigned int low, high;
-TSCount  out;
-saveTimeStampCountInto( low, high );
-out = high;
-out = (out << 32) + low;
-return out;
-}

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

comparison VMS.c @ 50:8f7141a9272e