X-Git-Url: http://plrg.eecs.uci.edu/git/?p=c11tester.git;a=blobdiff_plain;f=mymemory.cc;h=44985fa3aebc0d3fc32f97c0606b3c7ef11154a8;hp=9d598af7dfec11d77add4ecf02dbc845df924e00;hb=5fa2efec1354b2781ff0b29460ec8e9b8fa75991;hpb=72e4ac7e09dac04744d8e1b4d8166a23fd197786 diff --git a/mymemory.cc b/mymemory.cc index 9d598af7..44985fa3 100644 --- a/mymemory.cc +++ b/mymemory.cc @@ -1,69 +1,221 @@ -#include "mymemory.h" -#include "snapshot.h" -#include "snapshotimp.h" +#include #include #include -#if !USE_CHECKPOINTING +#include +#include +#include + +#include "mymemory.h" +#include "snapshot.h" +#include "common.h" + +#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 -void *MYMALLOC(size_t size) { -#if USE_CHECKPOINTING - static void *(*mallocp)(size_t size); +/** Non-snapshotting calloc for our use. */ +void *model_calloc(size_t count, size_t size) +{ +#if USE_MPROTECT_SNAPSHOT + static void *(*callocp)(size_t count, size_t size) = NULL; char *error; void *ptr; - + /* get address of libc malloc */ - if (!mallocp) { - mallocp = ( void * ( * )( size_t ) )dlsym(RTLD_NEXT, "malloc"); + if (!callocp) { + callocp = (void * (*)(size_t, size_t))dlsym(RTLD_NEXT, "calloc"); if ((error = dlerror()) != NULL) { fputs(error, stderr); - exit(1); + exit(EXIT_FAILURE); } } - ptr = mallocp(size); + ptr = callocp(count, size); return ptr; #else - if( !sTheRecord ){ - createSharedLibrary(); + if (!sStaticSpace) + sStaticSpace = create_shared_mspace(); + return mspace_calloc(sStaticSpace, count, size); +#endif +} + +/** Non-snapshotting malloc for our use. */ +void *model_malloc(size_t size) +{ +#if USE_MPROTECT_SNAPSHOT + static void *(*mallocp)(size_t size) = NULL; + char *error; + void *ptr; + + /* get address of libc malloc */ + if (!mallocp) { + mallocp = (void * (*)(size_t))dlsym(RTLD_NEXT, "malloc"); + if ((error = dlerror()) != NULL) { + fputs(error, stderr); + exit(EXIT_FAILURE); + } } - if( NULL == sStaticSpace ) - sStaticSpace = create_mspace_with_base( ( void * )( sTheRecord->mSharedMemoryBase ), SHARED_MEMORY_DEFAULT -sizeof( struct Snapshot_t ), 1 ); - return mspace_malloc( sStaticSpace, size ); + ptr = mallocp(size); + return ptr; +#else + if (!sStaticSpace) + sStaticSpace = create_shared_mspace(); + return mspace_malloc(sStaticSpace, size); #endif } -void MYFREE(void *ptr) { -#if USE_CHECKPOINTING +/** @brief Snapshotting malloc, for use by model-checker (not user progs) */ +void * snapshot_malloc(size_t size) +{ + void *tmp = mspace_malloc(model_snapshot_space, size); + ASSERT(tmp); + return tmp; +} + +/** @brief Snapshotting calloc, for use by model-checker (not user progs) */ +void * snapshot_calloc(size_t count, size_t size) +{ + void *tmp = mspace_calloc(model_snapshot_space, count, size); + ASSERT(tmp); + return tmp; +} + +/** @brief Snapshotting realloc, for use by model-checker (not user progs) */ +void *snapshot_realloc(void *ptr, size_t size) +{ + void *tmp = mspace_realloc(model_snapshot_space, ptr, size); + ASSERT(tmp); + return tmp; +} + +/** @brief Snapshotting free, for use by model-checker (not user progs) */ +void snapshot_free(void *ptr) +{ + mspace_free(model_snapshot_space, ptr); +} + +/** Non-snapshotting free for our use. */ +void model_free(void *ptr) +{ +#if USE_MPROTECT_SNAPSHOT static void (*freep)(void *); char *error; /* get address of libc free */ if (!freep) { - freep = ( void ( * )( void * ) )dlsym(RTLD_NEXT, "free"); + freep = (void (*)(void *))dlsym(RTLD_NEXT, "free"); if ((error = dlerror()) != NULL) { fputs(error, stderr); - exit(1); + exit(EXIT_FAILURE); } } freep(ptr); #else - mspace_free( sStaticSpace, ptr ); + mspace_free(sStaticSpace, ptr); #endif } -mspace mySpace = NULL; -void *malloc( size_t size ) { - return mspace_malloc( mySpace, size ); + +/** Bootstrap allocation. Problem is that the dynamic linker calls require + * calloc to work and calloc requires the dynamic linker to work. */ + +#define BOOTSTRAPBYTES 4096 +char bootstrapmemory[BOOTSTRAPBYTES]; +size_t offset = 0; + +void * HandleEarlyAllocationRequest(size_t sz) +{ + /* Align to 8 byte boundary */ + sz = (sz + 7) & ~7; + + if (sz > (BOOTSTRAPBYTES-offset)) { + model_print("OUT OF BOOTSTRAP MEMORY\n"); + exit(EXIT_FAILURE); + } + + void *pointer = (void *)&bootstrapmemory[offset]; + offset += sz; + return pointer; +} + +/** @brief Global mspace reference for the model-checker's snapshotting heap */ +mspace model_snapshot_space = NULL; + +#if USE_MPROTECT_SNAPSHOT + +/** @brief Global mspace reference for the user's snapshotting heap */ +mspace user_snapshot_space = NULL; + +/** Check whether this is bootstrapped memory that we should not free */ +static bool DontFree(void *ptr) +{ + return (ptr >= (&bootstrapmemory[0]) && ptr < (&bootstrapmemory[BOOTSTRAPBYTES])); +} + +/** @brief Snapshotting malloc implementation for user programs */ +void *malloc(size_t size) +{ + if (user_snapshot_space) { + void *tmp = mspace_malloc(user_snapshot_space, size); + ASSERT(tmp); + return tmp; + } else + return HandleEarlyAllocationRequest(size); +} + +/** @brief Snapshotting free implementation for user programs */ +void free(void * ptr) +{ + if (!DontFree(ptr)) + mspace_free(user_snapshot_space, ptr); +} + +/** @brief Snapshotting realloc implementation for user programs */ +void *realloc(void *ptr, size_t size) +{ + void *tmp = mspace_realloc(user_snapshot_space, ptr, size); + ASSERT(tmp); + return tmp; +} + +/** @brief Snapshotting calloc implementation for user programs */ +void * calloc(size_t num, size_t size) +{ + if (user_snapshot_space) { + void *tmp = mspace_calloc(user_snapshot_space, num, size); + ASSERT(tmp); + return tmp; + } else { + void *tmp = HandleEarlyAllocationRequest(size * num); + memset(tmp, 0, size * num); + return tmp; + } +} + +/** @brief Snapshotting new operator for user programs */ +void * operator new(size_t size) throw(std::bad_alloc) +{ + return malloc(size); } -void free( void * ptr ){ - mspace_free( mySpace, ptr ); +/** @brief Snapshotting delete operator for user programs */ +void operator delete(void *p) throw() +{ + free(p); } -void * operator new(size_t size) throw(std::bad_alloc) { - return MYMALLOC(size); +/** @brief Snapshotting new[] operator for user programs */ +void * operator new[](size_t size) throw(std::bad_alloc) +{ + return malloc(size); } -void operator delete(void *p) throw() { - MYFREE(p); +/** @brief Snapshotting delete[] operator for user programs */ +void operator delete[](void *p, size_t size) +{ + free(p); } +#endif /* USE_MPROTECT_SNAPSHOT */