VMS/VMS_Implementations/VMS_impls/VMS__MC_shared

comparison vmalloc.c @ 139:99798e4438a6

Merge of Malloc2 and inter master requests

author	Merten Sach <msach@mailbox.tu-berlin.de>
date	Mon, 19 Sep 2011 16:12:01 +0200
parents	d0aa5a796fc5 99343ffe1918
children	2c8f3cf6c058

comparison

equal deleted inserted replaced

-:535b0f2c7154
+:faee7dc89616
 #include "VMS.h"
 #include "Histogram/Histogram.h"
 #define MAX_UINT64 0xFFFFFFFFFFFFFFFF
+inline void
+sendFreeReqst_lib(int receiverID, void *ptrToFree, VirtProcr *animPr);
+inline void
+sendFreeReqst_master(int receiverID, void *ptrToFree);
 //A MallocProlog is a head element if the HigherInMem variable is NULL
 //A Chunk is free if the prevChunkInFreeList variable is NULL
 /*
 }
 return foundChunk;
 }
+/*
+* This function is called by code which is part of the master loop.
+* This reads the animating coreID from the MasterEnv and calls the normal malloc
+* in VMS__malloc_on_core
+*/
+void *
+VMS__malloc( size_t sizeRequested)
+{
+return VMS__malloc_on_core(sizeRequested, _VMSMasterEnv->currentMasterProcrID);
+}
+/*
+* This is called by the plugin. This call to VMS_malloc_on_core is run on the
+* slave VPs stack so there is no switch to the VMS runtime.
+*/
+void *
+VMS__malloc_in_lib(size_t sizeRequested, VirtProcr *VProcr)
+{
+return VMS__malloc_on_core(sizeRequested, VProcr->coreAnimatedBy);
+}
 /*
 * This is sequential code, meant to only be called from the Master, not from
 * any slave VPs.
 */
-void *VMS__malloc( size_t sizeRequested )
+void *VMS__malloc_on_core( size_t sizeRequested, int procrID )
 {
 //============================= MEASUREMENT STUFF ========================
 #ifdef MEAS__TIME_MALLOC
 int32 startStamp, endStamp;
 saveLowTimeStampCountInto( startStamp );
 #endif
 //========================================================================
-MallocArrays* freeLists = _VMSMasterEnv->freeLists;
+MallocArrays* freeLists = _VMSMasterEnv->freeLists[procrID];
 MallocProlog* foundChunk;
+MallocPrologAllocated* returnChunk;
 //Return a small chunk if the requested size is smaller than 128B
 if(sizeRequested <= LOWER_BOUND)
 {
 uint32 freeListIdx = (sizeRequested-1)/SMALL_CHUNK_SIZE;
 if(freeLists->smallChunks[freeListIdx] == NULL)
 foundChunk = searchChunk(freeLists, SMALL_CHUNK_SIZE*(freeListIdx+1), 0);
 else
 foundChunk = removeSmallChunk(freeLists, freeListIdx);
-//Mark as allocated
+returnChunk = (MallocPrologAllocated*)foundChunk;
-foundChunk->prevChunkInFreeList = NULL;
+returnChunk->prevChunkInFreeList = NULL;//indicates elem currently allocated
-return foundChunk + 1;
+returnChunk->procrID = procrID;
+return returnChunk + 1;
 }
 //Calculate the expected container. Start one higher to have a Chunk that's
 //always big enough.
 uint32 containerIdx = getContainer(sizeRequested);
 foundChunk = searchChunk(freeLists, sizeRequested, containerIdx);
 else
 foundChunk = removeChunk(freeLists, containerIdx);
 //Mark as allocated
-foundChunk->prevChunkInFreeList = NULL;
+returnChunk = (MallocPrologAllocated*)foundChunk;
+returnChunk->prevChunkInFreeList = NULL;//indicates elem currently allocated
+returnChunk->procrID = procrID;
 //============================= MEASUREMENT STUFF ========================
 #ifdef MEAS__TIME_MALLOC
 saveLowTimeStampCountInto( endStamp );
 addIntervalToHist( startStamp, endStamp, _VMSMasterEnv->mallocTimeHist );
 #endif
 //========================================================================
 //skip over the prolog by adding its size to the pointer return
-return foundChunk + 1;
+return returnChunk + 1;
+}
+/*
+* This free is called for a master loop. It decides whether the allocation of
+* chunk was done on the same core. If it was it calls VMS__free_on_core
+* otherwise it sends a message to the responsible core.
+*/
+void
+VMS__free(void *ptrToFree)
+{
+MallocPrologAllocated *chunk = (MallocPrologAllocated*)ptrToFree - 1;
+if(chunk->procrID == _VMSMasterEnv->currentMasterProcrID)
+{
+VMS__free_on_core(ptrToFree, _VMSMasterEnv->currentMasterProcrID);
+}
+else
+{
+sendFreeReqst_master(chunk->procrID, ptrToFree);
+}
+}
+/*
+* This free is called for the plugins. It decides whether the allocation of
+* chunk was done on the same core. If it was it calls VMS__free_on_core
+* otherwise it sends a message to the responsible core.
+*/
+void
+VMS__free_in_lib(void *ptrToFree, VirtProcr *VProc)
+{
+MallocPrologAllocated *chunk = (MallocPrologAllocated*)ptrToFree - 1;
+if(chunk->procrID == VProc->coreAnimatedBy)
+{
+VMS__free_on_core(ptrToFree, VProc->coreAnimatedBy);
+}
+else
+{
+sendFreeReqst_lib(chunk->procrID, ptrToFree, VProc);
+}
+}
+/*
+* This is called form a masterVP and request an free from a different masterVP.
+* The free of the request structure is done after the request is handled.
+*/
+inline void
+sendFreeReqst_master(int receiverID, void *ptrToFree)
+{
+InterVMSCoreReqst *freeReqst = VMS__malloc(sizeof(InterVMSCoreReqst));
+freeReqst->freePtr = ptrToFree;
+freeReqst->secondReqType = transfer_free_ptr;
+sendInterMasterReqst(receiverID, (InterMasterReqst*)freeReqst);
+}
+/*
+* This is called if the free is called from the plugin. This requests an inter
+* master request from his master.
+*/
+inline void
+sendFreeReqst_lib(int receiverID, void *ptrToFree, VirtProcr *animPr )
+{
+VMSSemReq reqData;
+InterVMSCoreReqst *freeReqst = VMS__malloc(sizeof(InterVMSCoreReqst));
+freeReqst->freePtr = ptrToFree;
+freeReqst->secondReqType = transfer_free_ptr;
+reqData.reqType  = interMasterReqst;
+reqData.receiverID   = receiverID;
+reqData.data  = (void*)freeReqst;
+VMS__send_VMSSem_request( (void*)&reqData, animPr );
 }
 /*
 * This is sequential code, meant to only be called from the Master, not from
 * any slave VPs.
 */
 void
-VMS__free( void *ptrToFree )
+VMS__free_on_core( void *ptrToFree, int procrID )
 {
 //============================= MEASUREMENT STUFF ========================
 #ifdef MEAS__TIME_MALLOC
 int32 startStamp, endStamp;
 saveLowTimeStampCountInto( startStamp );
 #endif
 //========================================================================
-MallocArrays* freeLists = _VMSMasterEnv->freeLists;
+MallocArrays* freeLists = _VMSMasterEnv->freeLists[procrID];
 MallocProlog *chunkToFree = (MallocProlog*)ptrToFree - 1;
 uint32 containerIdx;
 //Check for free neighbors
 if(chunkToFree->nextLowerInMem)
 */
 MallocArrays *
 VMS_ext__create_free_list()
 {
 //Initialize containers for small chunks and fill with zeros
-_VMSMasterEnv->freeLists = (MallocArrays*)malloc( sizeof(MallocArrays) );
+MallocArrays *freeLists = (MallocArrays*)malloc( sizeof(MallocArrays) );
-MallocArrays *freeLists = _VMSMasterEnv->freeLists;
 freeLists->smallChunks =
 (MallocProlog**)malloc(SMALL_CHUNK_COUNT*sizeof(MallocProlog*));
 memset((void*)freeLists->smallChunks,
 0,SMALL_CHUNK_COUNT*sizeof(MallocProlog*));
 firstChunk->nextLowerInMem = NULL;
 firstChunk->nextHigherInMem = (MallocProlog*)((uintptr_t)firstChunk +
 MALLOC_ADDITIONAL_MEM_FROM_OS_SIZE - sizeof(MallocProlog*));
 firstChunk->nextChunkInFreeList = NULL;
 //previous element in the queue is the container
-firstChunk->prevChunkInFreeList = &freeLists->bigChunks[container-2];
+firstChunk->prevChunkInFreeList = (MallocProlog*)&freeLists->bigChunks[container-2];
 freeLists->bigChunks[container-2] = firstChunk;
 //Insert into bit search list
 if(container <= 65)
-freeLists->bigChunksSearchVector[0] |= ((uint64)1 << (container-2));
+freeLists->bigChunksSearchVector[0] = ((uint64)1 << (container-2));
 else
-freeLists->bigChunksSearchVector[1] |= ((uint64)1 << (container-66));
+freeLists->bigChunksSearchVector[1] = ((uint64)1 << (container-66));
 //Create dummy chunk to mark the top of stack this is of course
 //never freed
 MallocProlog *dummyChunk = firstChunk->nextHigherInMem;
 dummyChunk->nextHigherInMem = dummyChunk+1;
 VMS_ext__free_free_list( MallocArrays *freeLists )
 {
 free(freeLists->memSpace);
 free(freeLists->bigChunks);
 free(freeLists->smallChunks);
+free(freeLists);
 }

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

comparison vmalloc.c @ 139:99798e4438a6