VMS/VMS_Implementations/VMS_impls/VMS__MC_shared

comparison vmalloc.c @ 53:42dd44df1bb0

Init changed to only use VMS__malloc & uses VMS__malloc versions of utilities

author	Me
date	Mon, 01 Nov 2010 21:21:32 -0700
parents	8f7141a9272e
children	3bac84e4e56e

comparison

equal deleted inserted replaced

-:d69b822a5b7a
+:0d3829b76e44
 *
 * Created on November 14, 2009, 9:07 PM
 */
 #include <malloc.h>
+#include <stdlib.h>
 #include "VMS.h"
 /*Helper function
 *Insert a newly generated free chunk into the first spot on the free list.
 void
 VMS__free( void *ptrToFree )
 { MallocProlog *elemToFree, *nextLowerElem, *nextHigherElem;
 int32         lowerExistsAndIsFree, higherExistsAndIsFree, sizeOfElem;
-if( ptrToFree < _VMSMasterEnv->freeListHead->nextLowerInMem ||
+if( ptrToFree < (void*)_VMSMasterEnv->freeListHead->nextLowerInMem ||
-ptrToFree > _VMSMasterEnv->freeListHead->nextHigherInMem )
+ptrToFree > (void*)_VMSMasterEnv->freeListHead->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 *)((char *)ptrToFree - sizeof(MallocProlog));
 sizeOfElem =(int32)((char*)elemToFree->nextHigherInMem-(char*)elemToFree);
+if( elemToFree->prevChunkInFreeList != NULL )
+{ printf( "error: freeing same element twice!" ); exit(1);
+}
 _VMSMasterEnv->amtOfOutstandingMem -= sizeOfElem;
 nextLowerElem  = elemToFree->nextLowerInMem;
 nextHigherElem = elemToFree->nextHigherInMem;
 }
 }
+/*Allocates memory from the external system -- higher overhead
+*
+*Because of Linux's malloc throwing bizarre random faults when malloc is
+* used inside a VMS virtual processor, have to pass this as a request and
+* have the core loop do it when it gets around to it -- will look for these
+* chores leftover from the previous animation of masterVP the next time it
+* goes to animate the masterVP -- so it takes two separate masterVP
+* animations, separated by work, to complete an external malloc or
+* external free request.
+*
+*Thinking core loop accepts signals -- just looks if signal-location is
+* empty or not --
+*/
+void *
+VMS__malloc_in_ext( int32 sizeRequested )
+{
+/*
+//This is running in the master, so no chance for multiple cores to be
+// competing for the core's flag.
+if(  *(_VMSMasterEnv->coreLoopSignalAddr[ 0 ]) != 0 )
+{    //something has already signalled to core loop, so save the signal
+// and look, next time master animated, to see if can send it.
+//Note, the addr to put a signal is in the coreloop's frame, so just
+// checks it each time through -- make it volatile to avoid GCC
+// optimizations -- it's a coreloop local var that only changes
+// after jumping away.  The signal includes the addr to send the
+//return to -- even if just empty return completion-signal
+//
+//save the signal in some queue that the master looks at each time
+// it starts up -- one loc says if empty for fast common case --
+//something like that -- want to hide this inside this call -- but
+// think this has to come as a request -- req handler gives procr
+// back to master loop, which gives it back to req handler at point
+// it sees that core loop has sent return signal.  Something like
+// that.
+saveTheSignal
+}
+coreSigData->type = malloc;
+coreSigData->sizeToMalloc = sizeRequested;
+coreSigData->locToSignalCompletion = &figureOut;
+_VMSMasterEnv->coreLoopSignals[ 0 ] = coreSigData;
+*/
+//just risk system-stack faults until get this figured out
+return malloc( sizeRequested );
+}
+/*Frees memory that was allocated in the external system -- higher overhead
+*
+*As noted in external malloc comment, this is clunky 'cause the free has
+* to be called in the core loop.
+*/
+void
+VMS__free_in_ext( void *ptrToFree )
+{
+//just risk system-stack faults until get this figured out
+free( ptrToFree );
+//TODO: fix this -- so
+}
 /*Designed to be called from the main thread outside of VMS, during init
 */
 MallocProlog *
-VMS__create_free_list()
+VMS_ext__create_free_list()
 { 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->prevChunkInFreeList = NULL;
 //Use this addr to free the heap when cleanup
 freeListHead->nextLowerInMem      = firstChunk;
 //to identify top-of-heap elem, compare this addr to elem's next higher
-freeListHead->nextHigherInMem     = (char *)firstChunk +
+freeListHead->nextHigherInMem     = (void*)( (char*)firstChunk +
-MALLOC_ADDITIONAL_MEM_FROM_OS_SIZE;
+MALLOC_ADDITIONAL_MEM_FROM_OS_SIZE);
 freeListHead->nextChunkInFreeList = firstChunk;
 firstChunk->nextChunkInFreeList   = NULL;
 firstChunk->prevChunkInFreeList   = freeListHead;
 //next Higher has to be set to top of chunk, so can calc size in malloc
-firstChunk->nextHigherInMem       = (char *)firstChunk +
+firstChunk->nextHigherInMem       = (void*)( (char*)firstChunk +
-MALLOC_ADDITIONAL_MEM_FROM_OS_SIZE;
+MALLOC_ADDITIONAL_MEM_FROM_OS_SIZE);
 firstChunk->nextLowerInMem        = NULL; //identifies as bott of heap
+_VMSMasterEnv->amtOfOutstandingMem = 0; //none allocated yet
 return freeListHead;
 }

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

comparison vmalloc.c @ 53:42dd44df1bb0