X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=mymemory.cc;h=1f8b616020e481e795fd36f74bfa1d2ab56722cc;hb=c4fcfd684e2017658cd69cc491ffd94ff8fe9603;hp=08bd4e437c897967830d5dc760d0d4f27f351b50;hpb=2462c395788348d3c036154d9f8500096804fe29;p=c11tester.git diff --git a/mymemory.cc b/mymemory.cc index 08bd4e43..1f8b6160 100644 --- a/mymemory.cc +++ b/mymemory.cc @@ -1,13 +1,20 @@ -#include "mymemory.h" -#include "snapshot.h" -#include "snapshotimp.h" + +#include #include #include #include -#include +#include +#include + +#include "mymemory.h" +#include "snapshot.h" #include "common.h" +#include "threads-model.h" +#include "model.h" + #define REQUESTS_BEFORE_ALLOC 1024 -size_t allocatedReqs[ REQUESTS_BEFORE_ALLOC ] = { 0 }; + +size_t allocatedReqs[REQUESTS_BEFORE_ALLOC] = { 0 }; int nextRequest = 0; int howManyFreed = 0; #if !USE_MPROTECT_SNAPSHOT @@ -33,11 +40,8 @@ void *model_calloc(size_t count, size_t size) ptr = callocp(count, size); return ptr; #else - if (!snapshotrecord) { - createSharedMemory(); - } - if (NULL == sStaticSpace) - sStaticSpace = create_mspace_with_base(( void *)( snapshotrecord->mSharedMemoryBase), SHARED_MEMORY_DEFAULT -sizeof(struct SnapShot), 1); + if (!sStaticSpace) + sStaticSpace = create_shared_mspace(); return mspace_calloc(sStaticSpace, count, size); #endif } @@ -61,15 +65,37 @@ void *model_malloc(size_t size) ptr = mallocp(size); return ptr; #else - if (!snapshotrecord) { - createSharedMemory(); - } - if (NULL == sStaticSpace) - sStaticSpace = create_mspace_with_base(( void *)( snapshotrecord->mSharedMemoryBase), SHARED_MEMORY_DEFAULT -sizeof(struct SnapShot), 1); + if (!sStaticSpace) + sStaticSpace = create_shared_mspace(); return mspace_malloc(sStaticSpace, size); #endif } +/** Non-snapshotting malloc for our use. */ +void *model_realloc(void *ptr, size_t size) +{ +#if USE_MPROTECT_SNAPSHOT + static void *(*reallocp)(void *ptr, size_t size) = NULL; + char *error; + void *newptr; + + /* get address of libc malloc */ + if (!reallocp) { + reallocp = (void * (*)(size_t))dlsym(RTLD_NEXT, "realloc"); + if ((error = dlerror()) != NULL) { + fputs(error, stderr); + exit(EXIT_FAILURE); + } + } + newptr = reallocp(ptr, size); + return newptr; +#else + if (!sStaticSpace) + sStaticSpace = create_shared_mspace(); + return mspace_realloc(sStaticSpace, ptr, size); +#endif +} + /** @brief Snapshotting malloc, for use by model-checker (not user progs) */ void * snapshot_malloc(size_t size) { @@ -109,7 +135,7 @@ void model_free(void *ptr) /* 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(EXIT_FAILURE); @@ -121,11 +147,10 @@ void model_free(void *ptr) #endif } -/** Bootstrap allocation. Problem is that the dynamic linker calls - * require calloc to work and calloc requires the dynamic linker to - * work. */ +/** Bootstrap allocation. Problem is that the dynamic linker calls require + * calloc to work and calloc requires the dynamic linker to work. */ -#define BOOTSTRAPBYTES 4096 +#define BOOTSTRAPBYTES 131072 char bootstrapmemory[BOOTSTRAPBYTES]; size_t offset = 0; @@ -135,11 +160,11 @@ void * HandleEarlyAllocationRequest(size_t sz) sz = (sz + 7) & ~7; if (sz > (BOOTSTRAPBYTES-offset)) { - printf("OUT OF BOOTSTRAP MEMORY\n"); + model_print("OUT OF BOOTSTRAP MEMORY. Increase the size of BOOTSTRAPBYTES in mymemory.cc\n"); exit(EXIT_FAILURE); } - void *pointer= (void *)&bootstrapmemory[offset]; + void *pointer = (void *)&bootstrapmemory[offset]; offset += sz; return pointer; } @@ -149,9 +174,7 @@ mspace model_snapshot_space = NULL; #if USE_MPROTECT_SNAPSHOT -/** @brief Global mspace reference for the user's snapshotting heap - * @todo use this ONLY for user's allocations, not for internal snapshotting - * state */ +/** @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 */ @@ -160,13 +183,31 @@ static bool DontFree(void *ptr) return (ptr >= (&bootstrapmemory[0]) && ptr < (&bootstrapmemory[BOOTSTRAPBYTES])); } -/** @brief Snapshotting malloc implementation for user programs */ +/** + * @brief The allocator function for "user" allocation + * + * Should only be used for allocations which will not disturb the allocation + * patterns of a user thread. + */ +static void * user_malloc(size_t size) +{ + void *tmp = mspace_malloc(user_snapshot_space, size); + ASSERT(tmp); + return tmp; +} + +/** + * @brief Snapshotting malloc implementation for user programs + * + * Do NOT call this function from a model-checker context. Doing so may disrupt + * the allocation patterns of a user thread. + */ void *malloc(size_t size) { if (user_snapshot_space) { - void *tmp = mspace_malloc(user_snapshot_space, size); - ASSERT(tmp); - return tmp; + /* Only perform user allocations from user context */ + ASSERT(!model || thread_current()); + return user_malloc(size); } else return HandleEarlyAllocationRequest(size); } @@ -174,8 +215,9 @@ void *malloc(size_t size) /** @brief Snapshotting free implementation for user programs */ void free(void * ptr) { - if (!DontFree(ptr)) + if (!DontFree(ptr)) { mspace_free(user_snapshot_space, ptr); + } } /** @brief Snapshotting realloc implementation for user programs */ @@ -195,11 +237,23 @@ void * calloc(size_t num, size_t size) return tmp; } else { void *tmp = HandleEarlyAllocationRequest(size * num); - std::memset(tmp, 0, size * num); + memset(tmp, 0, size * num); return tmp; } } +/** @brief Snapshotting allocation function for use by the Thread class only */ +void * Thread_malloc(size_t size) +{ + return user_malloc(size); +} + +/** @brief Snapshotting free function for use by the Thread class only */ +void Thread_free(void *ptr) +{ + free(ptr); +} + /** @brief Snapshotting new operator for user programs */ void * operator new(size_t size) throw(std::bad_alloc) { @@ -223,4 +277,19 @@ void operator delete[](void *p, size_t size) { free(p); } -#endif /* USE_MPROTECT_SNAPSHOT */ + +#else /* !USE_MPROTECT_SNAPSHOT */ + +/** @brief Snapshotting allocation function for use by the Thread class only */ +void * Thread_malloc(size_t size) +{ + return snapshot_malloc(size); +} + +/** @brief Snapshotting free function for use by the Thread class only */ +void Thread_free(void *ptr) +{ + snapshot_free(ptr); +} + +#endif /* !USE_MPROTECT_SNAPSHOT */