From 328a2c09c2ee06d0e1c49ccb84877fa17b436a01 Mon Sep 17 00:00:00 2001 From: Brian Norris Date: Wed, 3 Oct 2012 11:08:36 -0700 Subject: [PATCH] replace malloc/calloc/free with snapshot_{malloc/calloc/free} We need to explicitly declare when we are requesting snapshotting memory, and we need to avoid using malloc, etc., directly. For now, this has no functional change, as the 'snapshot_*' functions just call the stdlib functions, but soon we may switch allocators to use a private heap. --- datarace.cc | 23 ++++++++++++----------- hashtable.h | 3 ++- schedule.cc | 4 ++-- threads.cc | 4 ++-- 4 files changed, 18 insertions(+), 16 deletions(-) diff --git a/datarace.cc b/datarace.cc index 1cc407b..2937430 100644 --- a/datarace.cc +++ b/datarace.cc @@ -3,13 +3,14 @@ #include "threads.h" #include #include +#include "mymemory.h" struct ShadowTable *root; std::vector unrealizedraces; /** This function initialized the data race detector. */ void initRaceDetector() { - root=(struct ShadowTable *) calloc(sizeof(struct ShadowTable),1); + root = (struct ShadowTable *)snapshot_calloc(sizeof(struct ShadowTable), 1); } /** This function looks up the entry in the shadow table corresponding to a @@ -19,13 +20,13 @@ static uint64_t * lookupAddressEntry(void * address) { #if BIT48 currtable=(struct ShadowTable *) currtable->array[(((uintptr_t)address)>>32)&MASK16BIT]; if (currtable==NULL) { - currtable=(struct ShadowTable *) (root->array[(((uintptr_t)address)>>32)&MASK16BIT]=calloc(sizeof(struct ShadowTable),1)); + currtable = (struct ShadowTable *)(root->array[(((uintptr_t)address)>>32)&MASK16BIT] = snapshot_calloc(sizeof(struct ShadowTable), 1)); } #endif struct ShadowBaseTable * basetable=(struct ShadowBaseTable *) currtable->array[(((uintptr_t)address)>>16)&MASK16BIT]; if (basetable==NULL) { - basetable=(struct ShadowBaseTable *) (currtable->array[(((uintptr_t)address)>>16)&MASK16BIT]=calloc(sizeof(struct ShadowBaseTable),1)); + basetable = (struct ShadowBaseTable *)(currtable->array[(((uintptr_t)address)>>16)&MASK16BIT] = snapshot_calloc(sizeof(struct ShadowBaseTable), 1)); } return &basetable->array[((uintptr_t)address)&MASK16BIT]; } @@ -57,14 +58,14 @@ static void expandRecord(uint64_t * shadow) { modelclock_t writeClock = WRITEVECTOR(shadowval); thread_id_t writeThread = int_to_id(WRTHREADID(shadowval)); - struct RaceRecord * record=(struct RaceRecord *)calloc(1,sizeof(struct RaceRecord)); + struct RaceRecord *record = (struct RaceRecord *)snapshot_calloc(1, sizeof(struct RaceRecord)); record->writeThread=writeThread; record->writeClock=writeClock; if (readClock!=0) { record->capacity=INITCAPACITY; - record->thread=(thread_id_t *) malloc(sizeof(thread_id_t)*record->capacity); - record->readClock=(modelclock_t *) malloc(sizeof(modelclock_t)*record->capacity); + record->thread = (thread_id_t *)snapshot_malloc(sizeof(thread_id_t)*record->capacity); + record->readClock = (modelclock_t *)snapshot_malloc(sizeof(modelclock_t)*record->capacity); record->numReads=1; record->thread[0]=readThread; record->readClock[0]=readClock; @@ -74,7 +75,7 @@ static void expandRecord(uint64_t * shadow) { /** This function is called when we detect a data race.*/ static void reportDataRace(thread_id_t oldthread, modelclock_t oldclock, bool isoldwrite, ModelAction *newaction, bool isnewwrite, void *address) { - struct DataRace * race=(struct DataRace *)malloc(sizeof(struct DataRace)); + struct DataRace *race = (struct DataRace *)snapshot_malloc(sizeof(struct DataRace)); race->oldthread=oldthread; race->oldclock=oldclock; race->isoldwrite=isoldwrite; @@ -243,12 +244,12 @@ void fullRaceCheckRead(thread_id_t thread, void *location, uint64_t * shadow, Cl if (copytoindex>=record->capacity) { int newCapacity=record->capacity*2; - thread_id_t *newthread=(thread_id_t *) malloc(sizeof(thread_id_t)*newCapacity); - modelclock_t * newreadClock=(modelclock_t *) malloc(sizeof(modelclock_t)*newCapacity); + thread_id_t *newthread = (thread_id_t *)snapshot_malloc(sizeof(thread_id_t)*newCapacity); + modelclock_t *newreadClock =( modelclock_t *)snapshot_malloc(sizeof(modelclock_t)*newCapacity); std::memcpy(newthread, record->thread, record->capacity*sizeof(thread_id_t)); std::memcpy(newreadClock, record->readClock, record->capacity*sizeof(modelclock_t)); - free(record->readClock); - free(record->thread); + snapshot_free(record->readClock); + snapshot_free(record->thread); record->readClock=newreadClock; record->thread=newthread; record->capacity=newCapacity; diff --git a/hashtable.h b/hashtable.h index 8302000..a337df4 100644 --- a/hashtable.h +++ b/hashtable.h @@ -7,6 +7,7 @@ #include #include +#include "mymemory.h" /** * Hashtable linked node class, for chained storage of hash table conflicts. By @@ -61,7 +62,7 @@ struct hashlistnode { * @tparam _free Provide your own 'free' for the table, or default to * snapshotting. */ -template +template class HashTable { public: /** diff --git a/schedule.cc b/schedule.cc index 7a703ab..b1b41c3 100644 --- a/schedule.cc +++ b/schedule.cc @@ -18,11 +18,11 @@ Scheduler::Scheduler() : void Scheduler::set_enabled(Thread *t, bool enabled_status) { int threadid=id_to_int(t->get_id()); if (threadid>=enabled_len) { - bool * new_enabled=(bool *)malloc(sizeof(bool)*(threadid+1)); + bool *new_enabled = (bool *)snapshot_malloc(sizeof(bool) * (threadid + 1)); memset(&new_enabled[enabled_len], 0, (threadid+1-enabled_len)*sizeof(bool)); if (is_enabled != NULL) { memcpy(new_enabled, is_enabled, enabled_len*sizeof(bool)); - free(is_enabled); + snapshot_free(is_enabled); } is_enabled=new_enabled; enabled_len=threadid+1; diff --git a/threads.cc b/threads.cc index 836bf2c..09efcae 100644 --- a/threads.cc +++ b/threads.cc @@ -12,13 +12,13 @@ /** Allocate a stack for a new thread. */ static void * stack_allocate(size_t size) { - return malloc(size); + return snapshot_malloc(size); } /** Free a stack for a terminated thread. */ static void stack_free(void *stack) { - free(stack); + snapshot_free(stack); } /** Return the currently executing thread. */ -- 2.34.1