From: Brian Norris <banorris@uci.edu>
Date: Wed, 3 Oct 2012 18:08:36 +0000 (-0700)
Subject: replace malloc/calloc/free with snapshot_{malloc/calloc/free}
X-Git-Tag: pldi2013~109^2~7
X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=328a2c09c2ee06d0e1c49ccb84877fa17b436a01;p=model-checker.git
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.
---
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 <stdio.h>
#include <cstring>
+#include "mymemory.h"
struct ShadowTable *root;
std::vector<struct DataRace *> 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 <stdlib.h>
#include <stdio.h>
+#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<typename _Key, typename _Val, typename _KeyInt, int _Shift=0, void * (* _malloc)(size_t)=malloc, void * (* _calloc)(size_t, size_t)=calloc, void (*_free)(void *)=free>
+template<typename _Key, typename _Val, typename _KeyInt, int _Shift=0, void * (* _malloc)(size_t)=snapshot_malloc, void * (* _calloc)(size_t, size_t)=snapshot_calloc, void (*_free)(void *)=snapshot_free>
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. */