X-Git-Url: http://plrg.eecs.uci.edu/git/?p=c11tester.git;a=blobdiff_plain;f=datarace.cc;h=76fbe936260294b96132cfddc47c605dba3e91ab;hp=41bfbe0eaa5679d77faa111502833205c936e540;hb=25b12680719a51fc81d1681a280e076920dcaabc;hpb=133e215362162a6146b51fe9ac4eec749cc3c6c5 diff --git a/datarace.cc b/datarace.cc index 41bfbe0e..76fbe936 100644 --- a/datarace.cc +++ b/datarace.cc @@ -9,11 +9,12 @@ #include "action.h" #include "execution.h" #include "stl-model.h" +#include static struct ShadowTable *root; -static SnapVector unrealizedraces; static void *memory_base; static void *memory_top; +static RaceSet * raceset; static const ModelExecution * get_execution() { @@ -26,6 +27,7 @@ void initRaceDetector() root = (struct ShadowTable *)snapshot_calloc(sizeof(struct ShadowTable), 1); memory_base = snapshot_calloc(sizeof(struct ShadowBaseTable) * SHADOWBASETABLES, 1); memory_top = ((char *)memory_base) + sizeof(struct ShadowBaseTable) * SHADOWBASETABLES; + raceset = new RaceSet(); } void * table_calloc(size_t size) @@ -58,6 +60,48 @@ static uint64_t * lookupAddressEntry(const void *address) return &basetable->array[((uintptr_t)address) & MASK16BIT]; } + +bool hasNonAtomicStore(const void *address) { + uint64_t * shadow = lookupAddressEntry(address); + uint64_t shadowval = *shadow; + if (ISSHORTRECORD(shadowval)) { + //Do we have a non atomic write with a non-zero clock + return ((WRITEVECTOR(shadowval) != 0) && !(ATOMICMASK & shadowval)); + } else { + if (shadowval == 0) + return false; + struct RaceRecord *record = (struct RaceRecord *)shadowval; + return !record->isAtomic && record->writeClock != 0; + } +} + +void setAtomicStoreFlag(const void *address) { + uint64_t * shadow = lookupAddressEntry(address); + uint64_t shadowval = *shadow; + if (ISSHORTRECORD(shadowval)) { + *shadow = shadowval | ATOMICMASK; + } else { + if (shadowval == 0) + return; + struct RaceRecord *record = (struct RaceRecord *)shadowval; + record->isAtomic = 1; + } +} + +void getStoreThreadAndClock(const void *address, thread_id_t * thread, modelclock_t * clock) { + uint64_t * shadow = lookupAddressEntry(address); + uint64_t shadowval = *shadow; + if (ISSHORTRECORD(shadowval)) { + //Do we have a non atomic write with a non-zero clock + *thread = WRTHREADID(shadowval); + *clock = WRITEVECTOR(shadowval); + } else { + struct RaceRecord *record = (struct RaceRecord *)shadowval; + *thread = record->writeThread; + *clock = record->writeClock; + } +} + /** * Compares a current clock-vector/thread-ID pair with a clock/thread-ID pair * to check the potential for a data race. @@ -68,7 +112,7 @@ static uint64_t * lookupAddressEntry(const void *address) * @return true if the current clock allows a race with the event at clock2/tid2 */ static bool clock_may_race(ClockVector *clock1, thread_id_t tid1, - modelclock_t clock2, thread_id_t tid2) + modelclock_t clock2, thread_id_t tid2) { return tid1 != tid2 && clock2 != 0 && clock1->getClock(tid2) <= clock2; } @@ -91,59 +135,51 @@ static void expandRecord(uint64_t *shadow) record->writeClock = writeClock; if (readClock != 0) { - record->capacity = INITCAPACITY; - 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->thread = (thread_id_t *)snapshot_malloc(sizeof(thread_id_t) * INITCAPACITY); + record->readClock = (modelclock_t *)snapshot_malloc(sizeof(modelclock_t) * INITCAPACITY); record->numReads = 1; + ASSERT(readThread >= 0); record->thread[0] = readThread; record->readClock[0] = readClock; } + if (shadowval & ATOMICMASK) + record->isAtomic = 1; *shadow = (uint64_t) record; } +#define FIRST_STACK_FRAME 2 + +unsigned int race_hash(struct DataRace *race) { + unsigned int hash = 0; + for(int i=FIRST_STACK_FRAME;i < race->numframes;i++) { + hash ^= ((uintptr_t)race->backtrace[i]); + hash = (hash >> 3) | (hash << 29); + } + return hash; +} + + +bool race_equals(struct DataRace *r1, struct DataRace *r2) { + if (r1->numframes != r2->numframes) + return false; + for(int i=FIRST_STACK_FRAME;i < r1->numframes;i++) { + if (r1->backtrace[i] != r2->backtrace[i]) + return false; + } + return true; +} + /** 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, const void *address) +static struct DataRace * reportDataRace(thread_id_t oldthread, modelclock_t oldclock, bool isoldwrite, ModelAction *newaction, bool isnewwrite, const void *address) { - struct DataRace *race = (struct DataRace *)snapshot_malloc(sizeof(struct DataRace)); + struct DataRace *race = (struct DataRace *)model_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->switch_to_master(NULL); -} - -/** - * @brief Check and report data races - * - * If the trace is feasible (a feasible prefix), clear out the list of - * unrealized data races, asserting any realized ones as execution bugs so that - * the model-checker will end the execution. - * - * @return True if any data races were realized - */ -bool checkDataRaces() -{ - if (get_execution()->isfeasibleprefix()) { - bool race_asserted = false; - /* Prune the non-racing unrealized dataraces */ - for (unsigned i = 0; i < unrealizedraces.size(); i++) { - struct DataRace *race = unrealizedraces[i]; - if (clock_may_race(race->newaction->get_cv(), race->newaction->get_tid(), race->oldclock, race->oldthread)) { - assert_race(race); - race_asserted = true; - } - snapshot_free(race); - } - unrealizedraces.clear(); - return race_asserted; - } - return false; + return race; } /** @@ -156,54 +192,62 @@ bool checkDataRaces() */ void assert_race(struct DataRace *race) { - model->assert_bug( - "Data race detected @ address %p:\n" - " Access 1: %5s in thread %2d @ clock %3u\n" - " Access 2: %5s in thread %2d @ clock %3u", - race->address, - race->isoldwrite ? "write" : "read", - id_to_int(race->oldthread), - race->oldclock, - race->isnewwrite ? "write" : "read", - id_to_int(race->newaction->get_tid()), - race->newaction->get_seq_number() - ); + model_print("Race detected at location: \n"); + backtrace_symbols_fd(race->backtrace, race->numframes, model_out); + model_print("\nData race detected @ address %p:\n" + " Access 1: %5s in thread %2d @ clock %3u\n" + " Access 2: %5s in thread %2d @ clock %3u\n\n", + race->address, + race->isoldwrite ? "write" : "read", + id_to_int(race->oldthread), + race->oldclock, + 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, void *location, uint64_t *shadow, ClockVector *currClock) +struct DataRace * fullRaceCheckWrite(thread_id_t thread, void *location, uint64_t *shadow, ClockVector *currClock) { struct RaceRecord *record = (struct RaceRecord *)(*shadow); + struct DataRace * race = NULL; /* Check for datarace against last read. */ - for (int i = 0; i < record->numReads; i++) { + for (int i = 0;i < record->numReads;i++) { modelclock_t readClock = record->readClock[i]; thread_id_t readThread = record->thread[i]; /* Note that readClock can't actuall be zero here, so it could be - optimized. */ + optimized. */ if (clock_may_race(currClock, thread, readClock, readThread)) { /* We have a datarace */ - reportDataRace(readThread, readClock, false, get_execution()->get_parent_action(thread), true, location); + race = reportDataRace(readThread, readClock, false, get_execution()->get_parent_action(thread), true, location); + goto Exit; } } /* Check for datarace against last write. */ - modelclock_t writeClock = record->writeClock; - thread_id_t writeThread = record->writeThread; + { + modelclock_t writeClock = record->writeClock; + thread_id_t writeThread = record->writeThread; - if (clock_may_race(currClock, thread, writeClock, writeThread)) { - /* We have a datarace */ - reportDataRace(writeThread, writeClock, true, get_execution()->get_parent_action(thread), true, location); + if (clock_may_race(currClock, thread, writeClock, writeThread)) { + /* We have a datarace */ + race = reportDataRace(writeThread, writeClock, true, get_execution()->get_parent_action(thread), true, location); + goto Exit; + } } - +Exit: record->numReads = 0; record->writeThread = thread; + record->isAtomic = 0; modelclock_t ourClock = currClock->getClock(thread); record->writeClock = ourClock; + return race; } /** This function does race detection on a write. */ @@ -212,10 +256,213 @@ void raceCheckWrite(thread_id_t thread, void *location) uint64_t *shadow = lookupAddressEntry(location); uint64_t shadowval = *shadow; ClockVector *currClock = get_execution()->get_cv(thread); + if (currClock == NULL) + return; + struct DataRace * race = NULL; /* Do full record */ if (shadowval != 0 && !ISSHORTRECORD(shadowval)) { - fullRaceCheckWrite(thread, location, shadow, currClock); + race = fullRaceCheckWrite(thread, location, shadow, currClock); + goto Exit; + } + + { + int threadid = id_to_int(thread); + modelclock_t ourClock = currClock->getClock(thread); + + /* Thread ID is too large or clock is too large. */ + if (threadid > MAXTHREADID || ourClock > MAXWRITEVECTOR) { + expandRecord(shadow); + race = fullRaceCheckWrite(thread, location, shadow, currClock); + goto Exit; + } + + + + { + /* Check for datarace against last read. */ + + modelclock_t readClock = READVECTOR(shadowval); + thread_id_t readThread = int_to_id(RDTHREADID(shadowval)); + + if (clock_may_race(currClock, thread, readClock, readThread)) { + /* We have a datarace */ + race = reportDataRace(readThread, readClock, false, get_execution()->get_parent_action(thread), true, location); + goto ShadowExit; + } + } + + { + /* Check for datarace against last write. */ + + modelclock_t writeClock = WRITEVECTOR(shadowval); + thread_id_t writeThread = int_to_id(WRTHREADID(shadowval)); + + if (clock_may_race(currClock, thread, writeClock, writeThread)) { + /* We have a datarace */ + race = reportDataRace(writeThread, writeClock, true, get_execution()->get_parent_action(thread), true, location); + goto ShadowExit; + } + } + +ShadowExit: + *shadow = ENCODEOP(0, 0, threadid, ourClock); + } + +Exit: + if (race) { + race->numframes=backtrace(race->backtrace, sizeof(race->backtrace)/sizeof(void*)); + if (raceset->add(race)) + assert_race(race); + else model_free(race); + } +} + + +/** This function does race detection for a write on an expanded record. */ +struct DataRace * atomfullRaceCheckWrite(thread_id_t thread, void *location, uint64_t *shadow, ClockVector *currClock) +{ + struct RaceRecord *record = (struct RaceRecord *)(*shadow); + struct DataRace * race = NULL; + + if (record->isAtomic) + goto Exit; + + /* Check for datarace against last read. */ + + for (int i = 0;i < record->numReads;i++) { + modelclock_t readClock = record->readClock[i]; + thread_id_t readThread = record->thread[i]; + + /* Note that readClock can't actuall be zero here, so it could be + optimized. */ + + if (clock_may_race(currClock, thread, readClock, readThread)) { + /* We have a datarace */ + race = reportDataRace(readThread, readClock, false, get_execution()->get_parent_action(thread), true, location); + goto Exit; + } + } + + /* Check for datarace against last write. */ + + { + modelclock_t writeClock = record->writeClock; + thread_id_t writeThread = record->writeThread; + + if (clock_may_race(currClock, thread, writeClock, writeThread)) { + /* We have a datarace */ + race = reportDataRace(writeThread, writeClock, true, get_execution()->get_parent_action(thread), true, location); + goto Exit; + } + } +Exit: + record->numReads = 0; + record->writeThread = thread; + record->isAtomic = 1; + modelclock_t ourClock = currClock->getClock(thread); + record->writeClock = ourClock; + return race; +} + +/** This function does race detection on a write. */ +void atomraceCheckWrite(thread_id_t thread, void *location) +{ + uint64_t *shadow = lookupAddressEntry(location); + uint64_t shadowval = *shadow; + ClockVector *currClock = get_execution()->get_cv(thread); + if (currClock == NULL) + return; + + struct DataRace * race = NULL; + /* Do full record */ + if (shadowval != 0 && !ISSHORTRECORD(shadowval)) { + race = atomfullRaceCheckWrite(thread, location, shadow, currClock); + goto Exit; + } + + { + int threadid = id_to_int(thread); + modelclock_t ourClock = currClock->getClock(thread); + + /* Thread ID is too large or clock is too large. */ + if (threadid > MAXTHREADID || ourClock > MAXWRITEVECTOR) { + expandRecord(shadow); + race = atomfullRaceCheckWrite(thread, location, shadow, currClock); + goto Exit; + } + + /* Can't race with atomic */ + if (shadowval & ATOMICMASK) + goto ShadowExit; + + { + /* Check for datarace against last read. */ + + modelclock_t readClock = READVECTOR(shadowval); + thread_id_t readThread = int_to_id(RDTHREADID(shadowval)); + + if (clock_may_race(currClock, thread, readClock, readThread)) { + /* We have a datarace */ + race = reportDataRace(readThread, readClock, false, get_execution()->get_parent_action(thread), true, location); + goto ShadowExit; + } + } + + { + /* Check for datarace against last write. */ + + modelclock_t writeClock = WRITEVECTOR(shadowval); + thread_id_t writeThread = int_to_id(WRTHREADID(shadowval)); + + if (clock_may_race(currClock, thread, writeClock, writeThread)) { + /* We have a datarace */ + race = reportDataRace(writeThread, writeClock, true, get_execution()->get_parent_action(thread), true, location); + goto ShadowExit; + } + } + +ShadowExit: + *shadow = ENCODEOP(0, 0, threadid, ourClock) | ATOMICMASK; + } + +Exit: + if (race) { + race->numframes=backtrace(race->backtrace, sizeof(race->backtrace)/sizeof(void*)); + if (raceset->add(race)) + assert_race(race); + else model_free(race); + } +} + +/** This function does race detection for a write on an expanded record. */ +void fullRecordWrite(thread_id_t thread, void *location, uint64_t *shadow, ClockVector *currClock) { + struct RaceRecord *record = (struct RaceRecord *)(*shadow); + record->numReads = 0; + record->writeThread = thread; + modelclock_t ourClock = currClock->getClock(thread); + record->writeClock = ourClock; + record->isAtomic = 1; +} + +/** This function does race detection for a write on an expanded record. */ +void fullRecordWriteNonAtomic(thread_id_t thread, void *location, uint64_t *shadow, ClockVector *currClock) { + struct RaceRecord *record = (struct RaceRecord *)(*shadow); + record->numReads = 0; + record->writeThread = thread; + modelclock_t ourClock = currClock->getClock(thread); + record->writeClock = ourClock; + record->isAtomic = 0; +} + +/** This function just updates metadata on atomic write. */ +void recordWrite(thread_id_t thread, void *location) { + uint64_t *shadow = lookupAddressEntry(location); + uint64_t shadowval = *shadow; + ClockVector *currClock = get_execution()->get_cv(thread); + /* Do full record */ + if (shadowval != 0 && !ISSHORTRECORD(shadowval)) { + fullRecordWrite(thread, location, shadow, currClock); return; } @@ -225,37 +472,48 @@ void raceCheckWrite(thread_id_t thread, void *location) /* Thread ID is too large or clock is too large. */ if (threadid > MAXTHREADID || ourClock > MAXWRITEVECTOR) { expandRecord(shadow); - fullRaceCheckWrite(thread, location, shadow, currClock); + fullRecordWrite(thread, location, shadow, currClock); return; } - /* Check for datarace against last read. */ - - modelclock_t readClock = READVECTOR(shadowval); - thread_id_t readThread = int_to_id(RDTHREADID(shadowval)); + *shadow = ENCODEOP(0, 0, threadid, ourClock) | ATOMICMASK; +} - if (clock_may_race(currClock, thread, readClock, readThread)) { - /* We have a datarace */ - reportDataRace(readThread, readClock, false, get_execution()->get_parent_action(thread), true, location); - } +/** This function just updates metadata on atomic write. */ +void recordCalloc(void *location, size_t size) { + thread_id_t thread = thread_current()->get_id(); + for(;size != 0;size--) { + uint64_t *shadow = lookupAddressEntry(location); + uint64_t shadowval = *shadow; + ClockVector *currClock = get_execution()->get_cv(thread); + /* Do full record */ + if (shadowval != 0 && !ISSHORTRECORD(shadowval)) { + fullRecordWriteNonAtomic(thread, location, shadow, currClock); + return; + } - /* Check for datarace against last write. */ + int threadid = id_to_int(thread); + modelclock_t ourClock = currClock->getClock(thread); - modelclock_t writeClock = WRITEVECTOR(shadowval); - thread_id_t writeThread = int_to_id(WRTHREADID(shadowval)); + /* Thread ID is too large or clock is too large. */ + if (threadid > MAXTHREADID || ourClock > MAXWRITEVECTOR) { + expandRecord(shadow); + fullRecordWriteNonAtomic(thread, location, shadow, currClock); + return; + } - if (clock_may_race(currClock, thread, writeClock, writeThread)) { - /* We have a datarace */ - reportDataRace(writeThread, writeClock, true, get_execution()->get_parent_action(thread), true, location); + *shadow = ENCODEOP(0, 0, threadid, ourClock); + location = (void *)(((char *) location) + 1); } - *shadow = ENCODEOP(0, 0, threadid, ourClock); } + + /** This function does race detection on a read for an expanded record. */ -void fullRaceCheckRead(thread_id_t thread, const void *location, uint64_t *shadow, ClockVector *currClock) +struct DataRace * fullRaceCheckRead(thread_id_t thread, const void *location, uint64_t *shadow, ClockVector *currClock) { struct RaceRecord *record = (struct RaceRecord *) (*shadow); - + struct DataRace * race = NULL; /* Check for datarace against last write. */ modelclock_t writeClock = record->writeClock; @@ -263,26 +521,27 @@ void fullRaceCheckRead(thread_id_t thread, const void *location, uint64_t *shado if (clock_may_race(currClock, thread, writeClock, writeThread)) { /* We have a datarace */ - reportDataRace(writeThread, writeClock, true, get_execution()->get_parent_action(thread), false, location); + race = reportDataRace(writeThread, writeClock, true, get_execution()->get_parent_action(thread), false, location); } /* Shorten vector when possible */ int copytoindex = 0; - for (int i = 0; i < record->numReads; i++) { + for (int i = 0;i < record->numReads;i++) { modelclock_t readClock = record->readClock[i]; thread_id_t readThread = record->thread[i]; - /* Note that is not really a datarace check as reads cannott - actually race. It is just determining that this read subsumes - another in the sense that either this read races or neither - read races. Note that readClock can't actually be zero, so it - could be optimized. */ + /* Note that is not really a datarace check as reads cannot + actually race. It is just determining that this read subsumes + another in the sense that either this read races or neither + read races. Note that readClock can't actually be zero, so it + could be optimized. */ if (clock_may_race(currClock, thread, readClock, readThread)) { /* Still need this read in vector */ if (copytoindex != i) { + ASSERT(record->thread[i] >= 0); record->readClock[copytoindex] = record->readClock[i]; record->thread[copytoindex] = record->thread[i]; } @@ -290,24 +549,31 @@ void fullRaceCheckRead(thread_id_t thread, const void *location, uint64_t *shado } } - if (copytoindex >= record->capacity) { - int newCapacity = record->capacity * 2; - 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)); - snapshot_free(record->readClock); - snapshot_free(record->thread); - record->readClock = newreadClock; - record->thread = newthread; - record->capacity = newCapacity; + if (__builtin_popcount(copytoindex) <= 1) { + if (copytoindex == 0) { + int newCapacity = INITCAPACITY; + record->thread = (thread_id_t *)snapshot_malloc(sizeof(thread_id_t) * newCapacity); + record->readClock = (modelclock_t *)snapshot_malloc(sizeof(modelclock_t) * newCapacity); + } else if (copytoindex>=INITCAPACITY) { + int newCapacity = copytoindex * 2; + 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, copytoindex * sizeof(thread_id_t)); + std::memcpy(newreadClock, record->readClock, copytoindex * sizeof(modelclock_t)); + snapshot_free(record->readClock); + snapshot_free(record->thread); + record->readClock = newreadClock; + record->thread = newthread; + } } modelclock_t ourClock = currClock->getClock(thread); + ASSERT(thread >= 0); record->thread[copytoindex] = thread; record->readClock[copytoindex] = ourClock; record->numReads = copytoindex + 1; + return race; } /** This function does race detection on a read. */ @@ -316,47 +582,122 @@ void raceCheckRead(thread_id_t thread, const void *location) uint64_t *shadow = lookupAddressEntry(location); uint64_t shadowval = *shadow; ClockVector *currClock = get_execution()->get_cv(thread); + if (currClock == NULL) + return; + + struct DataRace * race = NULL; /* Do full record */ if (shadowval != 0 && !ISSHORTRECORD(shadowval)) { - fullRaceCheckRead(thread, location, shadow, currClock); - return; + race = fullRaceCheckRead(thread, location, shadow, currClock); + goto Exit; } - int threadid = id_to_int(thread); - modelclock_t ourClock = currClock->getClock(thread); + { + int threadid = id_to_int(thread); + modelclock_t ourClock = currClock->getClock(thread); - /* Thread ID is too large or clock is too large. */ - if (threadid > MAXTHREADID || ourClock > MAXWRITEVECTOR) { - expandRecord(shadow); - fullRaceCheckRead(thread, location, shadow, currClock); - return; + /* Thread ID is too large or clock is too large. */ + if (threadid > MAXTHREADID || ourClock > MAXWRITEVECTOR) { + expandRecord(shadow); + race = fullRaceCheckRead(thread, location, shadow, currClock); + goto Exit; + } + + /* Check for datarace against last write. */ + + modelclock_t writeClock = WRITEVECTOR(shadowval); + thread_id_t writeThread = int_to_id(WRTHREADID(shadowval)); + + if (clock_may_race(currClock, thread, writeClock, writeThread)) { + /* We have a datarace */ + race = reportDataRace(writeThread, writeClock, true, get_execution()->get_parent_action(thread), false, location); + goto ShadowExit; + } + +ShadowExit: + { + modelclock_t readClock = READVECTOR(shadowval); + thread_id_t readThread = int_to_id(RDTHREADID(shadowval)); + + if (clock_may_race(currClock, thread, readClock, readThread)) { + /* We don't subsume this read... Have to expand record. */ + expandRecord(shadow); + fullRaceCheckRead(thread, location, shadow, currClock); + goto Exit; + } + } + + *shadow = ENCODEOP(threadid, ourClock, id_to_int(writeThread), writeClock) | (shadowval & ATOMICMASK); + } +Exit: + if (race) { + race->numframes=backtrace(race->backtrace, sizeof(race->backtrace)/sizeof(void*)); + if (raceset->add(race)) + assert_race(race); + else model_free(race); } +} + +/** This function does race detection on a read for an expanded record. */ +struct DataRace * atomfullRaceCheckRead(thread_id_t thread, const void *location, uint64_t *shadow, ClockVector *currClock) +{ + struct RaceRecord *record = (struct RaceRecord *) (*shadow); + struct DataRace * race = NULL; /* Check for datarace against last write. */ + if (record->isAtomic) + return NULL; - modelclock_t writeClock = WRITEVECTOR(shadowval); - thread_id_t writeThread = int_to_id(WRTHREADID(shadowval)); + modelclock_t writeClock = record->writeClock; + thread_id_t writeThread = record->writeThread; if (clock_may_race(currClock, thread, writeClock, writeThread)) { /* We have a datarace */ - reportDataRace(writeThread, writeClock, true, get_execution()->get_parent_action(thread), false, location); + race = reportDataRace(writeThread, writeClock, true, get_execution()->get_parent_action(thread), false, location); } + return race; +} - modelclock_t readClock = READVECTOR(shadowval); - thread_id_t readThread = int_to_id(RDTHREADID(shadowval)); - - if (clock_may_race(currClock, thread, readClock, readThread)) { - /* We don't subsume this read... Have to expand record. */ - expandRecord(shadow); - fullRaceCheckRead(thread, location, shadow, currClock); +/** This function does race detection on a read. */ +void atomraceCheckRead(thread_id_t thread, const void *location) +{ + uint64_t *shadow = lookupAddressEntry(location); + uint64_t shadowval = *shadow; + ClockVector *currClock = get_execution()->get_cv(thread); + if (currClock == NULL) return; + + struct DataRace * race = NULL; + + /* Do full record */ + if (shadowval != 0 && !ISSHORTRECORD(shadowval)) { + race = atomfullRaceCheckRead(thread, location, shadow, currClock); + goto Exit; } - *shadow = ENCODEOP(threadid, ourClock, id_to_int(writeThread), writeClock); -} + if (shadowval & ATOMICMASK) + return; -bool haveUnrealizedRaces() -{ - return !unrealizedraces.empty(); + { + /* Check for datarace against last write. */ + + modelclock_t writeClock = WRITEVECTOR(shadowval); + thread_id_t writeThread = int_to_id(WRTHREADID(shadowval)); + + if (clock_may_race(currClock, thread, writeClock, writeThread)) { + /* We have a datarace */ + race = reportDataRace(writeThread, writeClock, true, get_execution()->get_parent_action(thread), false, location); + goto Exit; + } + + + } +Exit: + if (race) { + race->numframes=backtrace(race->backtrace, sizeof(race->backtrace)/sizeof(void*)); + if (raceset->add(race)) + assert_race(race); + else model_free(race); + } }