#include "threads.h"
#include <stdio.h>
#include <cstring>
+#include "mymemory.h"
+#include "clockvector.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
#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];
}
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;
/** 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;
race->isnewwrite=isnewwrite;
race->address=address;
unrealizedraces.push_back(race);
- checkDataRaces();
+
+ /* If the race is realized, bail out now. */
+ if (checkDataRaces()) {
+ model->set_assert();
+ model->switch_to_master(NULL);
+ }
}
/** This function goes through the list of unrealized data races,
* removes the impossible ones, and print the realized ones. */
-void checkDataRaces() {
- if (true) {
+bool checkDataRaces() {
+ if (model->isfeasibleprefix()) {
/* Prune the non-racing unrealized dataraces */
unsigned int i,newloc=0;
for(i=0;i<unrealizedraces.size();i++) {
}
if (newloc!=i)
unrealizedraces.resize(newloc);
- for(i=0;i<unrealizedraces.size();i++) {
- struct DataRace * race=unrealizedraces[i];
- printRace(race);
+
+ if (unrealizedraces.size()!=0) {
+ /* We have an actual realized race. */
+ for(i=0;i<unrealizedraces.size();i++) {
+ struct DataRace * race=unrealizedraces[i];
+ printRace(race);
+ }
+ return true;
}
}
+ return false;
}
void printRace(struct DataRace * race) {
printf("Datarace detected\n");
printf("Location %p\n", race->address);
- printf("Initial access: thread %u clock %u, iswrite %u\n",race->oldthread,race->oldclock, race->isoldwrite);
- printf("Second access: thread %u, iswrite %u\n", race->newaction->get_tid(), race->isnewwrite);
+ printf("Initial access: thread %u clock %u, iswrite %u\n", id_to_int(race->oldthread), race->oldclock, race->isoldwrite);
+ printf("Second access: thread %u clock %u, iswrite %u\n", id_to_int(race->newaction->get_tid()), race->newaction->get_seq_number(), race->isnewwrite);
}
/** This function does race detection for a write on an expanded record. */
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;