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

annotate vmalloc.c @ 62:dd3e60aeae26

find changesets by author, revision, files, or words in the commit message
Middle of fixing for -O3.. works -O0 still -- hard-code field offsets in assbly
author Me
date Fri, 12 Nov 2010 07:36:01 -0800
parents 3bac84e4e56e
children a6c442d52590 13b22ffb8a2f
rev   line source
Me@50 1 /*
Me@50 2 * Copyright 2009 OpenSourceCodeStewardshipFoundation.org
Me@50 3 * Licensed under GNU General Public License version 2
Me@50 4 *
Me@50 5 * Author: seanhalle@yahoo.com
Me@50 6 *
Me@50 7 * Created on November 14, 2009, 9:07 PM
Me@50 8 */
Me@50 9
Me@50 10 #include <malloc.h>
Me@53 11 #include <stdlib.h>
Me@50 12
Me@50 13 #include "VMS.h"
Me@50 14
Me@50 15 /*Helper function
Me@50 16 *Insert a newly generated free chunk into the first spot on the free list.
Me@50 17 * The chunk is cast as a MallocProlog, so the various pointers in it are
Me@50 18 * accessed with C's help -- and the size of the prolog is easily added to
Me@50 19 * the pointer when a chunk is returned to the app -- so C handles changes
Me@50 20 * in pointer sizes among machines.
Me@50 21 *
Me@50 22 *The list head is a normal MallocProlog struct -- identified by its
Me@50 23 * prevChunkInFreeList being NULL -- the only one.
Me@50 24 *
Me@50 25 *The end of the list is identified by next chunk being NULL, as usual.
Me@50 26 */
Me@50 27 void inline
Me@50 28 add_chunk_to_free_list( MallocProlog *chunk, MallocProlog *listHead )
Me@50 29 {
Me@50 30 chunk->nextChunkInFreeList = listHead->nextChunkInFreeList;
Me@50 31 if( chunk->nextChunkInFreeList != NULL ) //if not last in free list
Me@50 32 chunk->nextChunkInFreeList->prevChunkInFreeList = chunk;
Me@50 33 chunk->prevChunkInFreeList = listHead;
Me@50 34 listHead->nextChunkInFreeList = chunk;
Me@50 35 }
Me@50 36
Me@50 37
Me@50 38 /*This is sequential code, meant to only be called from the Master, not from
Me@50 39 * any slave VPs.
Me@50 40 *Search down list, checking size by the nextHigherInMem pointer, to find
Me@50 41 * first chunk bigger than size needed.
Me@50 42 *Shave off the extra and make it into a new free-list element, hook it in
Me@50 43 * then return the address of the found element plus size of prolog.
Me@50 44 *
Me@50 45 *Will find a
Me@50 46 */
Me@50 47 void *
Me@50 48 VMS__malloc( int32 sizeRequested )
Me@50 49 { MallocProlog *foundElem = NULL, *currElem, *newElem;
Me@50 50 int32 amountExtra, foundElemIsTopOfHeap, sizeConsumed,sizeOfFound;
Me@50 51
Me@50 52 //step up the size to be aligned at 16-byte boundary, prob better ways
Me@50 53 sizeRequested = ((sizeRequested + 16) >> 4) << 4;
Me@50 54 currElem = (_VMSMasterEnv->freeListHead)->nextChunkInFreeList;
Me@50 55
Me@50 56 while( currElem != NULL )
Me@50 57 { //check if size of currElem is big enough
Me@50 58 sizeOfFound=(int32)((char*)currElem->nextHigherInMem -(char*)currElem);
Me@50 59 amountExtra = sizeOfFound - sizeRequested - sizeof(MallocProlog);
Me@50 60 if( amountExtra > 0 )
Me@50 61 { //found it, get out of loop
Me@50 62 foundElem = currElem;
Me@50 63 currElem = NULL;
Me@50 64 }
Me@50 65 else
Me@50 66 currElem = currElem->nextChunkInFreeList;
Me@50 67 }
Me@50 68
Me@50 69 if( foundElem == NULL )
Me@55 70 { ERROR("\nmalloc failed\n")
Me@60 71 return (void *)NULL; //indicates malloc failed
Me@50 72 }
Me@50 73 //Using a kludge to identify the element that is the top chunk in the
Me@50 74 // heap -- saving top-of-heap addr in head's nextHigherInMem -- and
Me@50 75 // save addr of start of heap in head's nextLowerInMem
Me@50 76 //Will handle top of Heap specially
Me@50 77 foundElemIsTopOfHeap = foundElem->nextHigherInMem ==
Me@50 78 _VMSMasterEnv->freeListHead->nextHigherInMem;
Me@50 79
Me@50 80 //before shave off and try to insert new elem, remove found elem
Me@50 81 //note, foundElem will never be the head, so always has valid prevChunk
Me@50 82 foundElem->prevChunkInFreeList->nextChunkInFreeList =
Me@50 83 foundElem->nextChunkInFreeList;
Me@50 84 if( foundElem->nextChunkInFreeList != NULL )
Me@50 85 { foundElem->nextChunkInFreeList->prevChunkInFreeList =
Me@50 86 foundElem->prevChunkInFreeList;
Me@50 87 }
Me@50 88 foundElem->prevChunkInFreeList = NULL;//indicates elem currently allocated
Me@50 89
Me@50 90 //if enough, turn extra into new elem & insert it
Me@50 91 if( amountExtra > 64 )
Me@50 92 { //make new elem by adding to addr of curr elem then casting
Me@50 93 sizeConsumed = sizeof(MallocProlog) + sizeRequested;
Me@50 94 newElem = (MallocProlog *)( (char *)foundElem + sizeConsumed );
Me@50 95 newElem->nextHigherInMem = foundElem->nextHigherInMem;
Me@50 96 newElem->nextLowerInMem = foundElem;
Me@50 97 foundElem->nextHigherInMem = newElem;
Me@50 98
Me@50 99 if( ! foundElemIsTopOfHeap )
Me@50 100 { //there is no next higher for top of heap, so can't write to it
Me@50 101 newElem->nextHigherInMem->nextLowerInMem = newElem;
Me@50 102 }
Me@50 103 add_chunk_to_free_list( newElem, _VMSMasterEnv->freeListHead );
Me@50 104 }
Me@50 105 else
Me@50 106 {
Me@50 107 sizeConsumed = sizeOfFound;
Me@50 108 }
Me@50 109 _VMSMasterEnv->amtOfOutstandingMem += sizeConsumed;
Me@50 110
Me@50 111 //skip over the prolog by adding its size to the pointer return
Me@50 112 return (void *)((char *)foundElem + sizeof(MallocProlog));
Me@50 113 }
Me@50 114
Me@50 115
Me@50 116 /*This is sequential code -- only to be called from the Master
Me@50 117 * When free, subtract the size of prolog from pointer, then cast it to a
Me@50 118 * MallocProlog. Then check the nextLower and nextHigher chunks to see if
Me@50 119 * one or both are also free, and coalesce if so, and if neither free, then
Me@50 120 * add this one to free-list.
Me@50 121 */
Me@50 122 void
Me@50 123 VMS__free( void *ptrToFree )
Me@50 124 { MallocProlog *elemToFree, *nextLowerElem, *nextHigherElem;
Me@50 125 int32 lowerExistsAndIsFree, higherExistsAndIsFree, sizeOfElem;
Me@50 126
Me@53 127 if( ptrToFree < (void*)_VMSMasterEnv->freeListHead->nextLowerInMem ||
Me@53 128 ptrToFree > (void*)_VMSMasterEnv->freeListHead->nextHigherInMem )
Me@50 129 { //outside the range of data owned by VMS's malloc, so do nothing
Me@50 130 return;
Me@50 131 }
Me@50 132 //subtract size of prolog to get pointer to prolog, then cast
Me@50 133 elemToFree = (MallocProlog *)((char *)ptrToFree - sizeof(MallocProlog));
Me@50 134 sizeOfElem =(int32)((char*)elemToFree->nextHigherInMem-(char*)elemToFree);
Me@53 135
Me@53 136 if( elemToFree->prevChunkInFreeList != NULL )
Me@53 137 { printf( "error: freeing same element twice!" ); exit(1);
Me@53 138 }
Me@53 139
Me@50 140 _VMSMasterEnv->amtOfOutstandingMem -= sizeOfElem;
Me@50 141
Me@50 142 nextLowerElem = elemToFree->nextLowerInMem;
Me@50 143 nextHigherElem = elemToFree->nextHigherInMem;
Me@50 144
Me@50 145 if( nextHigherElem == NULL )
Me@50 146 higherExistsAndIsFree = FALSE;
Me@50 147 else //okay exists, now check if in the free-list by checking back ptr
Me@50 148 higherExistsAndIsFree = (nextHigherElem->prevChunkInFreeList != NULL);
Me@50 149
Me@50 150 if( nextLowerElem == NULL )
Me@50 151 lowerExistsAndIsFree = FALSE;
Me@50 152 else //okay, it exists, now check if it's free
Me@50 153 lowerExistsAndIsFree = (nextLowerElem->prevChunkInFreeList != NULL);
Me@50 154
Me@50 155
Me@50 156 //now, know what exists and what's free
Me@50 157 if( lowerExistsAndIsFree )
Me@50 158 { if( higherExistsAndIsFree )
Me@50 159 { //both exist and are free, so coalesce all three
Me@50 160 //First, remove higher from free-list
Me@50 161 nextHigherElem->prevChunkInFreeList->nextChunkInFreeList =
Me@50 162 nextHigherElem->nextChunkInFreeList;
Me@50 163 if( nextHigherElem->nextChunkInFreeList != NULL ) //end-of-list?
Me@50 164 nextHigherElem->nextChunkInFreeList->prevChunkInFreeList =
Me@50 165 nextHigherElem->prevChunkInFreeList;
Me@50 166 //Now, fix-up sequence-in-mem list -- by side-effect, this also
Me@50 167 // changes size of the lower elem, which is still in free-list
Me@50 168 nextLowerElem->nextHigherInMem = nextHigherElem->nextHigherInMem;
Me@50 169 if( nextHigherElem->nextHigherInMem !=
Me@50 170 _VMSMasterEnv->freeListHead->nextHigherInMem )
Me@50 171 nextHigherElem->nextHigherInMem->nextLowerInMem = nextLowerElem;
Me@50 172 //notice didn't do anything to elemToFree -- it simply is no
Me@50 173 // longer reachable from any of the lists. Wonder if could be a
Me@50 174 // security leak because left valid addresses in it,
Me@50 175 // but don't care for now.
Me@50 176 }
Me@50 177 else
Me@50 178 { //lower is the only of the two that exists and is free,
Me@50 179 //In this case, no adjustment to free-list, just change mem-list.
Me@50 180 // By side-effect, changes size of the lower elem
Me@50 181 nextLowerElem->nextHigherInMem = elemToFree->nextHigherInMem;
Me@50 182 if( elemToFree->nextHigherInMem !=
Me@50 183 _VMSMasterEnv->freeListHead->nextHigherInMem )
Me@50 184 elemToFree->nextHigherInMem->nextLowerInMem = nextLowerElem;
Me@50 185 }
Me@50 186 }
Me@50 187 else
Me@50 188 { //lower either doesn't exist or isn't free, so check higher
Me@50 189 if( higherExistsAndIsFree )
Me@50 190 { //higher exists and is the only of the two free
Me@50 191 //First, in free-list, replace higher elem with the one to free
Me@50 192 elemToFree->nextChunkInFreeList=nextHigherElem->nextChunkInFreeList;
Me@50 193 elemToFree->prevChunkInFreeList=nextHigherElem->prevChunkInFreeList;
Me@50 194 elemToFree->prevChunkInFreeList->nextChunkInFreeList = elemToFree;
Me@50 195 if( elemToFree->nextChunkInFreeList != NULL ) // end-of-list?
Me@50 196 elemToFree->nextChunkInFreeList->prevChunkInFreeList =elemToFree;
Me@50 197 //Now chg mem-list. By side-effect, changes size of elemToFree
Me@50 198 elemToFree->nextHigherInMem = nextHigherElem->nextHigherInMem;
Me@50 199 if( elemToFree->nextHigherInMem !=
Me@50 200 _VMSMasterEnv->freeListHead->nextHigherInMem )
Me@50 201 elemToFree->nextHigherInMem->nextLowerInMem = elemToFree;
Me@50 202 }
Me@50 203 else
Me@50 204 { //neither lower nor higher is availabe to coalesce so add to list
Me@50 205 // this makes prev chunk ptr non-null, which indicates it's free
Me@50 206 elemToFree->nextChunkInFreeList =
Me@50 207 _VMSMasterEnv->freeListHead->nextChunkInFreeList;
Me@50 208 _VMSMasterEnv->freeListHead->nextChunkInFreeList = elemToFree;
Me@50 209 if( elemToFree->nextChunkInFreeList != NULL ) // end-of-list?
Me@50 210 elemToFree->nextChunkInFreeList->prevChunkInFreeList =elemToFree;
Me@50 211 elemToFree->prevChunkInFreeList = _VMSMasterEnv->freeListHead;
Me@50 212 }
Me@50 213 }
Me@50 214
Me@50 215 }
Me@50 216
Me@50 217
Me@53 218 /*Allocates memory from the external system -- higher overhead
Me@53 219 *
Me@53 220 *Because of Linux's malloc throwing bizarre random faults when malloc is
Me@53 221 * used inside a VMS virtual processor, have to pass this as a request and
Me@53 222 * have the core loop do it when it gets around to it -- will look for these
Me@53 223 * chores leftover from the previous animation of masterVP the next time it
Me@53 224 * goes to animate the masterVP -- so it takes two separate masterVP
Me@53 225 * animations, separated by work, to complete an external malloc or
Me@53 226 * external free request.
Me@53 227 *
Me@53 228 *Thinking core loop accepts signals -- just looks if signal-location is
Me@53 229 * empty or not --
Me@53 230 */
Me@53 231 void *
Me@53 232 VMS__malloc_in_ext( int32 sizeRequested )
Me@53 233 {
Me@53 234 /*
Me@53 235 //This is running in the master, so no chance for multiple cores to be
Me@53 236 // competing for the core's flag.
Me@53 237 if( *(_VMSMasterEnv->coreLoopSignalAddr[ 0 ]) != 0 )
Me@53 238 { //something has already signalled to core loop, so save the signal
Me@53 239 // and look, next time master animated, to see if can send it.
Me@53 240 //Note, the addr to put a signal is in the coreloop's frame, so just
Me@53 241 // checks it each time through -- make it volatile to avoid GCC
Me@53 242 // optimizations -- it's a coreloop local var that only changes
Me@53 243 // after jumping away. The signal includes the addr to send the
Me@53 244 //return to -- even if just empty return completion-signal
Me@53 245 //
Me@53 246 //save the signal in some queue that the master looks at each time
Me@53 247 // it starts up -- one loc says if empty for fast common case --
Me@53 248 //something like that -- want to hide this inside this call -- but
Me@53 249 // think this has to come as a request -- req handler gives procr
Me@53 250 // back to master loop, which gives it back to req handler at point
Me@53 251 // it sees that core loop has sent return signal. Something like
Me@53 252 // that.
Me@53 253 saveTheSignal
Me@53 254
Me@53 255 }
Me@53 256 coreSigData->type = malloc;
Me@53 257 coreSigData->sizeToMalloc = sizeRequested;
Me@53 258 coreSigData->locToSignalCompletion = &figureOut;
Me@53 259 _VMSMasterEnv->coreLoopSignals[ 0 ] = coreSigData;
Me@53 260 */
Me@53 261 //just risk system-stack faults until get this figured out
Me@53 262 return malloc( sizeRequested );
Me@53 263 }
Me@53 264
Me@53 265
Me@53 266 /*Frees memory that was allocated in the external system -- higher overhead
Me@53 267 *
Me@53 268 *As noted in external malloc comment, this is clunky 'cause the free has
Me@53 269 * to be called in the core loop.
Me@53 270 */
Me@53 271 void
Me@53 272 VMS__free_in_ext( void *ptrToFree )
Me@53 273 {
Me@53 274 //just risk system-stack faults until get this figured out
Me@53 275 free( ptrToFree );
Me@53 276
Me@53 277 //TODO: fix this -- so
Me@53 278 }
Me@53 279
Me@53 280
Me@50 281 /*Designed to be called from the main thread outside of VMS, during init
Me@50 282 */
Me@50 283 MallocProlog *
Me@53 284 VMS_ext__create_free_list()
Me@50 285 { MallocProlog *freeListHead, *firstChunk;
Me@50 286
Me@50 287 //Note, this is running in the main thread -- all increases in malloc
Me@50 288 // mem and all frees of it must be done in this thread, with the
Me@50 289 // thread's original stack available
Me@50 290 freeListHead = malloc( sizeof(MallocProlog) );
Me@50 291 firstChunk = malloc( MALLOC_ADDITIONAL_MEM_FROM_OS_SIZE );
Me@50 292 if( firstChunk == NULL ) {printf("malloc error\n"); exit(1);}
Me@50 293
Me@50 294 freeListHead->prevChunkInFreeList = NULL;
Me@50 295 //Use this addr to free the heap when cleanup
Me@50 296 freeListHead->nextLowerInMem = firstChunk;
Me@50 297 //to identify top-of-heap elem, compare this addr to elem's next higher
Me@53 298 freeListHead->nextHigherInMem = (void*)( (char*)firstChunk +
Me@53 299 MALLOC_ADDITIONAL_MEM_FROM_OS_SIZE);
Me@50 300 freeListHead->nextChunkInFreeList = firstChunk;
Me@50 301
Me@50 302 firstChunk->nextChunkInFreeList = NULL;
Me@50 303 firstChunk->prevChunkInFreeList = freeListHead;
Me@50 304 //next Higher has to be set to top of chunk, so can calc size in malloc
Me@53 305 firstChunk->nextHigherInMem = (void*)( (char*)firstChunk +
Me@53 306 MALLOC_ADDITIONAL_MEM_FROM_OS_SIZE);
Me@50 307 firstChunk->nextLowerInMem = NULL; //identifies as bott of heap
Me@53 308
Me@53 309 _VMSMasterEnv->amtOfOutstandingMem = 0; //none allocated yet
Me@50 310
Me@50 311 return freeListHead;
Me@50 312 }
Me@50 313
Me@50 314
Me@50 315 /*Designed to be called from the main thread outside of VMS, during cleanup
Me@50 316 */
Me@50 317 void
Me@50 318 VMS_ext__free_free_list( MallocProlog *freeListHead )
Me@50 319 {
Me@50 320 //stashed a ptr to the one and only bug chunk malloc'd from OS in the
Me@50 321 // free list head's next lower in mem pointer
Me@50 322 free( freeListHead->nextLowerInMem );
Me@50 323
Me@50 324 //don't free the head -- it'll be in an array eventually -- free whole
Me@50 325 // array when all the free lists linked from it have already been freed
Me@50 326 }
Me@50 327