fixing calloc(), fix Makefile

Adding sbrk() calls and hooked into free also to avoid freeing sbrked memory...
checked both fork and paged implementation. seems to work Also everytime we
switch between fork and paged impl, we need to rebuild so adding snapshot.h as
dependency to mymemory.cc in makefile

diff --git a/Makefile b/Makefile
index 7e07cc8f3f91f045832cd47155f14185d64e62a1..fbbc3a1c39419b5fe7527976cfb2966389d338d9 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -44,7 +44,7 @@ $(LIB_SO): $(MODEL_O) $(MODEL_H) $(SHMEM_O) $(SHMEM_H)
 malloc.o: malloc.c
        $(CC) -fPIC -c malloc.c -DMSPACES -DONLY_MSPACES $(CPPFLAGS)
 
-mymemory.o: mymemory.h snapshotimp.h mymemory.cc
+mymemory.o: mymemory.h snapshotimp.h snapshot.h mymemory.cc
        $(CXX) -fPIC -c mymemory.cc $(CPPFLAGS)
 
 snapshot.o: mymemory.h snapshot.h snapshotimp.h snapshot.cc

diff --git a/mymemory.cc b/mymemory.cc
index 2b9c44d516282e1041487c6d0d1a5f1a78a1f472..245b2701807710bbca6c1f69ea1df662e89e9181 100644 (file)
--- a/mymemory.cc
+++ b/mymemory.cc
@@ -3,6 +3,12 @@
 #include "snapshotimp.h"
 #include <stdio.h>
 #include <dlfcn.h>
+#include <unistd.h>
+#include <cstring>
+#define REQUESTS_BEFORE_ALLOC 1024
+size_t allocatedReqs[ REQUESTS_BEFORE_ALLOC ] = { 0 };
+int nextRequest = 0;
+int howManyFreed = 0;
 #if !USE_MPROTECT_SNAPSHOT
 static mspace sStaticSpace = NULL;
 #endif
@@ -96,15 +102,47 @@ void * basemySpace = NULL;
 
 //Subramanian --- please make these work for the fork based approach
 
+/** Adding the fix for not able to allocate through a reimplemented calloc at the beginning before instantiating our allocator
+A bit circumspect about adding an sbrk. linux docs say to avoid using it... */
+
+void * HandleEarlyAllocationRequest( size_t sz ){
+       if( 0 == mySpace ){
+               void * returnAddress = sbrk( sz );
+               if( nextRequest >= REQUESTS_BEFORE_ALLOC ){
+                       exit( EXIT_FAILURE );
+               }
+               allocatedReqs[ nextRequest++ ] = ( size_t )returnAddress;
+               return returnAddress;
+       }
+       return NULL;
+}
+
+/** The fact that I am not expecting more than a handful requests is implicit in my not using a binary search here*/
+
+bool DontFree( void * ptr ){
+       if( howManyFreed == nextRequest ) return false; //a minor optimization to reduce the number of instructions executed on each free call....
+       if( NULL == ptr ) return true;
+       for( int i =  nextRequest - 1; i >= 0; --i ){
+               if( allocatedReqs[ i ] ==  ( size_t )ptr ) {
+                       ++howManyFreed;
+                       return true;
+               }
+       }
+       return false;
+}
+
 /** Snapshotting malloc implementation for user programs. */
 
 void *malloc( size_t size ) {
+       void * earlyReq = HandleEarlyAllocationRequest( size );
+       if( earlyReq ) return earlyReq;
        return mspace_malloc( mySpace, size );
 }
 
 /** Snapshotting free implementation for user programs. */
 
 void free( void * ptr ){
+       if( DontFree( ptr ) ) return;
        mspace_free( mySpace, ptr );
 }
 
@@ -114,8 +152,21 @@ void *realloc( void *ptr, size_t size ){
        return mspace_realloc( mySpace, ptr, size );
 }
 
+/** Snapshotting calloc implementation for user programs. */
+
+void * calloc( size_t num, size_t size ){
+       void * earlyReq = HandleEarlyAllocationRequest( size * num );
+       if( earlyReq ) {
+               std::memset( earlyReq, 0, size * num );
+               return earlyReq;
+       }
+       return mspace_calloc( mySpace, num, size );
+}
+
+
 /** Snapshotting new operator for user programs. */
 
+
 void * operator new(size_t size) throw(std::bad_alloc) {
        return malloc(size);
 }