VMS/VMS_Implementations/VMS_impls/VMS__MC_shared

comparison vmalloc.c @ 134:a9b72021f053

Distributed memory management w/o free requests working

author	Merten Sach <msach@mailbox.tu-berlin.de>
date	Fri, 16 Sep 2011 16:19:24 +0200
parents	dbfc8382d546
children	0b49fd35afc1

comparison

equal deleted inserted replaced

-:2ea90c770565
+:0877c22b1191
 #include <malloc.h>
 #include <inttypes.h>
 #include <stdlib.h>
 #include <stdio.h>
-#include "ProcrContext.h"
+#include "VMS.h"
 #include "Histogram/Histogram.h"
 /*Helper function
 *Insert a newly generated free chunk into the first spot on the free list.
 * The chunk is cast as a MallocProlog, so the various pointers in it are
 VMS__malloc_on_core( size_t sizeRequested, int procrID)
 { MallocProlog *foundElem = NULL, *currElem, *newElem;
 MallocPrologAllocated *returnElem;
 ssize_t        amountExtra, sizeConsumed,sizeOfFound;
 uint32        foundElemIsTopOfHeap;
+printf("Malloc on core %d\n", procrID);
 //============================= MEASUREMENT STUFF ========================
 #ifdef MEAS__TIME_MALLOC
 int32 startStamp, endStamp;
 saveLowTimeStampCountInto( startStamp );
 #endif
 //========================================================================
 //step up the size to be aligned at 16-byte boundary, prob better ways
 sizeRequested = (sizeRequested + 16) & ~15;
-currElem = (_VMSMasterEnv->freeListHead[_VMSMasterEnv->currentMasterProcrID])
+currElem = (_VMSMasterEnv->freeListHead[procrID])
 ->nextChunkInFreeList;
 while( currElem != NULL )
 {    //check if size of currElem is big enough
 sizeOfFound=(size_t)((uintptr_t)currElem->nextHigherInMem -(uintptr_t)currElem);
 //Using a kludge to identify the element that is the top chunk in the
 // heap -- saving top-of-heap addr in head's nextHigherInMem -- and
 // save addr of start of heap in head's nextLowerInMem
 //Will handle top of Heap specially
 foundElemIsTopOfHeap = foundElem->nextHigherInMem ==
-_VMSMasterEnv->freeListHead->nextHigherInMem;
+_VMSMasterEnv->freeListHead[procrID]->nextHigherInMem;
 //before shave off and try to insert new elem, remove found elem
 //note, foundElem will never be the head, so always has valid prevChunk
 foundElem->prevChunkInFreeList->nextChunkInFreeList =
 foundElem->nextChunkInFreeList;
 //if enough, turn extra into new elem & insert it
 if( amountExtra > 64 )
 {   //make new elem by adding to addr of curr elem then casting
 sizeConsumed = sizeof(MallocProlog) + sizeRequested;
 newElem = (MallocProlog *)( (uintptr_t)returnElem + sizeConsumed );
-newElem->nextLowerInMem    = returnElem; //This is evil (but why?)
+newElem->nextLowerInMem    = (MallocProlog*)returnElem;
-newElem->nextHigherInMem   = returnElem->nextHigherInMem; //This is evil (but why?)
+newElem->nextHigherInMem   = returnElem->nextHigherInMem;
 returnElem->nextHigherInMem = newElem;
 if( ! foundElemIsTopOfHeap )
 {  //there is no next higher for top of heap, so can't write to it
 newElem->nextHigherInMem->nextLowerInMem = newElem;
 }
-add_chunk_to_free_list( newElem, _VMSMasterEnv->freeListHead );
+add_chunk_to_free_list( newElem, _VMSMasterEnv->freeListHead[procrID] );
 }
 else
 {
 sizeConsumed = sizeOfFound;
 }
 * otherwise it sends a message to the responsible core.
 */
 void
 VMS__free(void *ptrToFree)
 {
-MallocPrologAllocated chunk = (MallocPrologAllocated*)ptrToFree - 1;
+MallocPrologAllocated *chunk = (MallocPrologAllocated*)ptrToFree - 1;
 if(chunk->procrID == _VMSMasterEnv->currentMasterProcrID)
 {
 VMS__free_on_core(ptrToFree, _VMSMasterEnv->currentMasterProcrID);
 }
 else
 * otherwise it sends a message to the responsible core.
 */
 void
 VMS__free_in_lib(void *ptrToFree, VirtProcr *VProc)
 {
-MallocPrologAllocated chunk = (MallocPrologAllocated*)ptrToFree - 1;
+MallocPrologAllocated *chunk = (MallocPrologAllocated*)ptrToFree - 1;
+printf("Free from core %d for core %d\n", VProc->coreAnimatedBy, chunk->procrID);
 if(chunk->procrID == VProc->coreAnimatedBy)
 {
 VMS__free_on_core(ptrToFree, VProc->coreAnimatedBy);
 }
 else
 #ifdef MEAS__TIME_MALLOC
 int32 startStamp, endStamp;
 saveLowTimeStampCountInto( startStamp );
 #endif
 //========================================================================
-if( ptrToFree < (void*)_VMSMasterEnv->freeListHead->nextLowerInMem ||
+MallocProlog* masterListHead = _VMSMasterEnv->freeListHead[procrID];
-ptrToFree > (void*)_VMSMasterEnv->freeListHead->nextHigherInMem )
+if( ptrToFree < (void*)masterListHead->nextLowerInMem ||
+ptrToFree > (void*)masterListHead->nextHigherInMem )
 {    //outside the range of data owned by VMS's malloc, so do nothing
 return;
 }
 //subtract size of prolog to get pointer to prolog, then cast
 elemToFree = (MallocProlog *)((uintptr_t)ptrToFree - sizeof(MallocProlog));
 nextHigherElem->prevChunkInFreeList;
 //Now, fix-up sequence-in-mem list -- by side-effect, this also
 // changes size of the lower elem, which is still in free-list
 nextLowerElem->nextHigherInMem = nextHigherElem->nextHigherInMem;
 if( nextHigherElem->nextHigherInMem !=
-_VMSMasterEnv->freeListHead->nextHigherInMem )
+masterListHead->nextHigherInMem )
 nextHigherElem->nextHigherInMem->nextLowerInMem = nextLowerElem;
 //notice didn't do anything to elemToFree -- it simply is no
 // longer reachable from any of the lists.  Wonder if could be a
 // security leak because left valid addresses in it,
 // but don't care for now.
 {    //lower is the only of the two that exists and is free,
 //In this case, no adjustment to free-list, just change mem-list.
 // By side-effect, changes size of the lower elem
 nextLowerElem->nextHigherInMem = elemToFree->nextHigherInMem;
 if( elemToFree->nextHigherInMem !=
-_VMSMasterEnv->freeListHead->nextHigherInMem )
+masterListHead->nextHigherInMem )
 elemToFree->nextHigherInMem->nextLowerInMem = nextLowerElem;
 }
 }
 else
 {    //lower either doesn't exist or isn't free, so check higher
 if( elemToFree->nextChunkInFreeList != NULL ) // end-of-list?
 elemToFree->nextChunkInFreeList->prevChunkInFreeList =elemToFree;
 //Now chg mem-list. By side-effect, changes size of elemToFree
 elemToFree->nextHigherInMem = nextHigherElem->nextHigherInMem;
 if( elemToFree->nextHigherInMem !=
-_VMSMasterEnv->freeListHead->nextHigherInMem )
+masterListHead->nextHigherInMem )
 elemToFree->nextHigherInMem->nextLowerInMem = elemToFree;
 }
 else
 {    //neither lower nor higher is availabe to coalesce so add to list
 // this makes prev chunk ptr non-null, which indicates it's free
 elemToFree->nextChunkInFreeList =
-_VMSMasterEnv->freeListHead->nextChunkInFreeList;
+masterListHead->nextChunkInFreeList;
-_VMSMasterEnv->freeListHead->nextChunkInFreeList = elemToFree;
+masterListHead->nextChunkInFreeList = elemToFree;
 if( elemToFree->nextChunkInFreeList != NULL ) // end-of-list?
 elemToFree->nextChunkInFreeList->prevChunkInFreeList =elemToFree;
-elemToFree->prevChunkInFreeList = _VMSMasterEnv->freeListHead;
+elemToFree->prevChunkInFreeList = masterListHead;
 }
 }
 //============================= MEASUREMENT STUFF ========================
 #ifdef MEAS__TIME_MALLOC
 saveLowTimeStampCountInto( endStamp );
 { MallocProlog *freeListHead, *firstChunk;
 //Note, this is running in the main thread -- all increases in malloc
 // mem and all frees of it must be done in this thread, with the
 // thread's original stack available
 freeListHead = malloc( sizeof(MallocProlog) );
 firstChunk   = malloc( MALLOC_ADDITIONAL_MEM_FROM_OS_SIZE );
 if( firstChunk == NULL ) {printf("malloc error\n"); exit(1);}
 //Touch memory to avoid page faults
 /*Designed to be called from the main thread outside of VMS, during cleanup
 */
 void
-VMS_ext__free_free_list( MallocProlog *freeListHead )
+VMS_ext__free_free_list( MallocProlog* freeListHeads[] )
 {
 //stashed a ptr to the one and only bug chunk malloc'd from OS in the
 // free list head's next lower in mem pointer
-free( freeListHead->nextLowerInMem );
+int i;
+for(i=0; i<NUM_CORES; i++)
+{
+free( freeListHeads[i]->nextLowerInMem );
+}
 //don't free the head -- it'll be in an array eventually -- free whole
 // array when all the free lists linked from it have already been freed
 }

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

comparison vmalloc.c @ 134:a9b72021f053