X-Git-Url: http://plrg.eecs.uci.edu/git/?p=c11tester.git;a=blobdiff_plain;f=datarace.cc;h=270e52310730febec1e97956c787a06c7b670b7e;hp=fb9ca61a10c38fb729ab7b2b71db33fc23a121dd;hb=616746ec12aae78b0d0262c009568109686cb000;hpb=9a97c2b585705b1a1870e799e387f95ea3b7b12c diff --git a/datarace.cc b/datarace.cc index fb9ca61a..270e5231 100644 --- a/datarace.cc +++ b/datarace.cc @@ -1,13 +1,17 @@ #include "datarace.h" -#include "threads.h" +#include "model.h" +#include "threads-model.h" #include #include +#include "mymemory.h" +#include "clockvector.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 @@ -17,13 +21,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]; } @@ -55,14 +59,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; @@ -71,12 +75,64 @@ static void expandRecord(uint64_t * shadow) { } /** This function is called when we detect a data race.*/ -static void reportDataRace() { - printf("The reportDataRace method should report useful things about this datarace!\n"); +static void reportDataRace(thread_id_t oldthread, modelclock_t oldclock, bool isoldwrite, ModelAction *newaction, bool isnewwrite, void *address) { + struct DataRace *race = (struct DataRace *)snapshot_malloc(sizeof(struct DataRace)); + race->oldthread=oldthread; + race->oldclock=oldclock; + race->isoldwrite=isoldwrite; + race->newaction=newaction; + race->isnewwrite=isnewwrite; + race->address=address; + unrealizedraces.push_back(race); + + /* 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. */ + +bool checkDataRaces() { + if (model->isfeasibleprefix()) { + /* Prune the non-racing unrealized dataraces */ + unsigned int i,newloc=0; + for(i=0;inewaction->get_cv(), race->newaction->get_tid(), race->oldclock, race->oldthread)) { + unrealizedraces[newloc++]=race; + } + } + if (newloc!=i) + unrealizedraces.resize(newloc); + + if (unrealizedraces.size()!=0) { + /* We have an actual realized race. */ + for(i=0;iaddress); + printf(" Access 1: %5s in thread %2d @ clock %3u\n", + race->isoldwrite ? "write" : "read", + id_to_int(race->oldthread), race->oldclock); + printf(" Access 2: %5s in thread %2d @ clock %3u\n", + race->isnewwrite ? "write" : "read", + id_to_int(race->newaction->get_tid()), race->newaction->get_seq_number()); } /** This function does race detection for a write on an expanded record. */ -void fullRaceCheckWrite(thread_id_t thread, uint64_t * shadow, ClockVector *currClock) { +void fullRaceCheckWrite(thread_id_t thread, void *location, uint64_t * shadow, ClockVector *currClock) { struct RaceRecord * record=(struct RaceRecord *) (*shadow); /* Check for datarace against last read. */ @@ -90,7 +146,7 @@ void fullRaceCheckWrite(thread_id_t thread, uint64_t * shadow, ClockVector *curr if (clock_may_race(currClock, thread, readClock, readThread)) { /* We have a datarace */ - reportDataRace(); + reportDataRace(readThread, readClock, false, model->get_parent_action(thread), true, location); } } @@ -101,7 +157,7 @@ void fullRaceCheckWrite(thread_id_t thread, uint64_t * shadow, ClockVector *curr if (clock_may_race(currClock, thread, writeClock, writeThread)) { /* We have a datarace */ - reportDataRace(); + reportDataRace(writeThread, writeClock, true, model->get_parent_action(thread), true, location); } record->numReads=0; @@ -117,7 +173,7 @@ void raceCheckWrite(thread_id_t thread, void *location, ClockVector *currClock) /* Do full record */ if (shadowval!=0&&!ISSHORTRECORD(shadowval)) { - fullRaceCheckWrite(thread, shadow, currClock); + fullRaceCheckWrite(thread, location, shadow, currClock); return; } @@ -127,7 +183,7 @@ void raceCheckWrite(thread_id_t thread, void *location, ClockVector *currClock) /* Thread ID is too large or clock is too large. */ if (threadid > MAXTHREADID || ourClock > MAXWRITEVECTOR) { expandRecord(shadow); - fullRaceCheckWrite(thread, shadow, currClock); + fullRaceCheckWrite(thread, location, shadow, currClock); return; } @@ -138,7 +194,7 @@ void raceCheckWrite(thread_id_t thread, void *location, ClockVector *currClock) if (clock_may_race(currClock, thread, readClock, readThread)) { /* We have a datarace */ - reportDataRace(); + reportDataRace(readThread, readClock, false, model->get_parent_action(thread), true, location); } /* Check for datarace against last write. */ @@ -148,13 +204,13 @@ void raceCheckWrite(thread_id_t thread, void *location, ClockVector *currClock) if (clock_may_race(currClock, thread, writeClock, writeThread)) { /* We have a datarace */ - reportDataRace(); + reportDataRace(writeThread, writeClock, true, model->get_parent_action(thread), true, location); } *shadow = ENCODEOP(0, 0, threadid, ourClock); } /** This function does race detection on a read for an expanded record. */ -void fullRaceCheckRead(thread_id_t thread, uint64_t * shadow, ClockVector *currClock) { +void fullRaceCheckRead(thread_id_t thread, void *location, uint64_t * shadow, ClockVector *currClock) { struct RaceRecord * record=(struct RaceRecord *) (*shadow); /* Check for datarace against last write. */ @@ -164,7 +220,7 @@ void fullRaceCheckRead(thread_id_t thread, uint64_t * shadow, ClockVector *currC if (clock_may_race(currClock, thread, writeClock, writeThread)) { /* We have a datarace */ - reportDataRace(); + reportDataRace(writeThread, writeClock, true, model->get_parent_action(thread), false, location); } /* Shorten vector when possible */ @@ -193,12 +249,12 @@ void fullRaceCheckRead(thread_id_t thread, uint64_t * shadow, ClockVector *currC 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; @@ -218,7 +274,7 @@ void raceCheckRead(thread_id_t thread, void *location, ClockVector *currClock) { /* Do full record */ if (shadowval!=0&&!ISSHORTRECORD(shadowval)) { - fullRaceCheckRead(thread, shadow, currClock); + fullRaceCheckRead(thread, location, shadow, currClock); return; } @@ -228,7 +284,7 @@ void raceCheckRead(thread_id_t thread, void *location, ClockVector *currClock) { /* Thread ID is too large or clock is too large. */ if (threadid > MAXTHREADID || ourClock > MAXWRITEVECTOR) { expandRecord(shadow); - fullRaceCheckRead(thread, shadow, currClock); + fullRaceCheckRead(thread, location, shadow, currClock); return; } @@ -239,7 +295,7 @@ void raceCheckRead(thread_id_t thread, void *location, ClockVector *currClock) { if (clock_may_race(currClock, thread, writeClock, writeThread)) { /* We have a datarace */ - reportDataRace(); + reportDataRace(writeThread, writeClock, true, model->get_parent_action(thread), false, location); } modelclock_t readClock = READVECTOR(shadowval); @@ -248,7 +304,7 @@ void raceCheckRead(thread_id_t thread, void *location, ClockVector *currClock) { if (clock_may_race(currClock, thread, readClock, readThread)) { /* We don't subsume this read... Have to expand record. */ expandRecord(shadow); - fullRaceCheckRead(thread, shadow, currClock); + fullRaceCheckRead(thread, location, shadow, currClock); return; }