VMS/VMS_Implementations/VMS_impls/VMS__MC_shared

comparison VMS.c @ 201:0320b49ca013

New include paths because of new project structure

author	Merten Sach <msach@mailbox.tu-berlin.de>
date	Mon, 13 Feb 2012 19:35:32 +0100
parents	de5e7c522f1f
children

comparison

equal deleted inserted replaced

-:d2370869bf6e
+:44222cde49c9
 #include <inttypes.h>
 #include <sys/time.h>
 #include "VMS.h"
 #include "ProcrContext.h"
-#include "Queue_impl/BlockingQueue.h"
+#include "C_Libraries/Queue_impl/BlockingQueue.h"
-#include "Histogram/Histogram.h"
+#include "C_Libraries/Histogram/Histogram.h"
 #define thdAttrs NULL
 //===========================================================================
 posix_memalign((void*)&_VMSMasterEnv, CACHELINE_SIZE, sizeof(MasterEnv) );
 memset( _VMSMasterEnv, 0, 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.
+//After this, all other mallocs are VMS_int__malloc.
 _VMSMasterEnv->freeLists        = VMS_ext__create_free_list();
 //============================= MEASUREMENT STUFF ========================
 #ifdef MEAS__TIME_MALLOC
 _VMSMasterEnv->reqHdlrHighTimeHist  = makeFixedBinHistExt( 100, 0, 200,
 "plugin_high_time_hist");
 #endif
 //========================================================================
-//===================== Only VMS__malloc after this ====================
+//===================== Only VMS_int__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(VirtProcr *) );
 //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
 for( coreIdx = 0; coreIdx < NUM_CORES; coreIdx++ )
 {
 readyToAnimateQs[ coreIdx ] = makeVMSQ();
 //============================= 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 *) );
 posix_memalign(&schedSlots, CACHELINE_SIZE, 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) );
 posix_memalign(&schedSlots[i], CACHELINE_SIZE, CACHELINE_SIZE );
 //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,
 void      *stackLocs;
 posix_memalign((void*)&newPr, CACHELINE_SIZE, sizeof(VirtProcr) ); //align to cacheline
 posix_memalign(&stackLocs, CACHELINE_SIZE, VIRT_PROCR_STACK_SIZE ); //align to cacheline
 if( stackLocs == 0 )
-{ perror("VMS__malloc stack"); exit(1); }
+{ perror("VMS_int__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
 */
 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.
+// been alloc'd with VMS_int__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 );
 * 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
+*The request handler has to call VMS_int__free_VMSReq for any of these
 */
 inline void
 VMS__add_sem_request_in_mallocd_VMSReqst( void *semReqData,
 VirtProcr *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;
 }
 { 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 =
 * 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
+*If the dissipated processor is the sole (remaining) owner of VMS_int__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 )
 {
 //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"
+//TODO: implement VMS_int__malloc system, including "give up ownership"
 //NOTE: initialData was given to the processor, so should either have
-// been alloc'd with VMS__malloc, or freed by the level above animPr.
+// been alloc'd with VMS_int__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( animatingPr->startOfStack );
 * 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 get all the
+*NOTE: the semantic plug-in is expected to use VMS_int__malloc to get all the
 * locations it needs, and give ownership to masterVP.  Then, they will be
 * automatically freed.
 *
 *In here,create one core-loop shut-down processor for each core loop and put
 * them all directly into the readyToAnimateQ.
 freeSchedSlots( allSchedSlots[ coreIdx ] );
 }
 #endif
-//All the environment data has been allocated with VMS__malloc, so just
+//All the environment data has been allocated with VMS_int__malloc, so just
 // free its internal big-chunk and all inside it disappear.
 /*
 readyToAnimateQs = _VMSMasterEnv->readyToAnimateQs;
 masterVPs        = _VMSMasterEnv->masterVPs;
 allSchedSlots    = _VMSMasterEnv->allSchedSlots;
 VMS__dissipate_procr( masterVPs[ coreIdx ] );
 freeSchedSlots( allSchedSlots[ coreIdx ] );
 }
-VMS__free( _VMSMasterEnv->readyToAnimateQs );
+VMS_int__free( _VMSMasterEnv->readyToAnimateQs );
-VMS__free( _VMSMasterEnv->masterVPs );
+VMS_int__free( _VMSMasterEnv->masterVPs );
-VMS__free( _VMSMasterEnv->allSchedSlots );
+VMS_int__free( _VMSMasterEnv->allSchedSlots );
 //============================= MEASUREMENT STUFF ========================
 #ifdef STATS__TURN_ON_PROBES
-freeDynArrayDeep( _VMSMasterEnv->dynIntervalProbesInfo, &VMS__free_probe);
+freeDynArrayDeep( _VMSMasterEnv->dynIntervalProbesInfo, &VMS_int__free_probe);
 #endif
 //========================================================================
 */
 //These are the only two that use system free
 VMS_ext__free_free_list( _VMSMasterEnv->freeLists );

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

comparison VMS.c @ 201:0320b49ca013