X-Git-Url: http://plrg.eecs.uci.edu/git/?p=c11tester.git;a=blobdiff_plain;f=datarace.cc;h=cfbe94bff3553761f81069c40ed63739db578e7a;hp=4558e2ba35472b3a0e98092f698ef5db31fb2fbd;hb=0636bb359706d39278eb31159aa612558784a22d;hpb=805cb1992146bc8f5d69e3e98a4b2f941a407001 diff --git a/datarace.cc b/datarace.cc index 4558e2ba..cfbe94bf 100644 --- a/datarace.cc +++ b/datarace.cc @@ -143,6 +143,8 @@ static void expandRecord(uint64_t *shadow) ASSERT(readThread >= 0); record->thread[0] = readThread; record->readClock[0] = readClock; + } else { + record->thread = NULL; } if (shadowval & ATOMICMASK) record->isAtomic = 1; @@ -160,7 +162,6 @@ unsigned int race_hash(struct DataRace *race) { return hash; } - bool race_equals(struct DataRace *r1, struct DataRace *r2) { if (r1->numframes != r2->numframes) return false; @@ -210,7 +211,7 @@ void assert_race(struct DataRace *race) } /** This function does race detection for a write on an expanded record. */ -struct DataRace * fullRaceCheckWrite(thread_id_t thread, void *location, uint64_t *shadow, ClockVector *currClock) +struct DataRace * fullRaceCheckWrite(thread_id_t thread, const void *location, uint64_t *shadow, ClockVector *currClock) { struct RaceRecord *record = (struct RaceRecord *)(*shadow); struct DataRace * race = NULL; @@ -232,7 +233,6 @@ struct DataRace * fullRaceCheckWrite(thread_id_t thread, void *location, uint64_ } /* Check for datarace against last write. */ - { modelclock_t writeClock = record->writeClock; thread_id_t writeThread = record->writeThread; @@ -279,11 +279,8 @@ void raceCheckWrite(thread_id_t thread, void *location) goto Exit; } - - { /* Check for datarace against last read. */ - modelclock_t readClock = READVECTOR(shadowval); thread_id_t readThread = int_to_id(RDTHREADID(shadowval)); @@ -296,7 +293,6 @@ void raceCheckWrite(thread_id_t thread, void *location) { /* Check for datarace against last write. */ - modelclock_t writeClock = WRITEVECTOR(shadowval); thread_id_t writeThread = int_to_id(WRTHREADID(shadowval)); @@ -320,9 +316,8 @@ Exit: } } - /** 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 DataRace * atomfullRaceCheckWrite(thread_id_t thread, const void *location, uint64_t *shadow, ClockVector *currClock) { struct RaceRecord *record = (struct RaceRecord *)(*shadow); struct DataRace * race = NULL; @@ -400,7 +395,6 @@ void atomraceCheckWrite(thread_id_t thread, void *location) { /* Check for datarace against last read. */ - modelclock_t readClock = READVECTOR(shadowval); thread_id_t readThread = int_to_id(RDTHREADID(shadowval)); @@ -413,7 +407,6 @@ void atomraceCheckWrite(thread_id_t thread, void *location) { /* Check for datarace against last write. */ - modelclock_t writeClock = WRITEVECTOR(shadowval); thread_id_t writeThread = int_to_id(WRTHREADID(shadowval)); @@ -509,8 +502,6 @@ void recordCalloc(void *location, size_t size) { } } - - /** This function does race detection on a read for an expanded record. */ struct DataRace * fullRaceCheckRead(thread_id_t thread, const void *location, uint64_t *shadow, ClockVector *currClock) { @@ -552,7 +543,7 @@ struct DataRace * fullRaceCheckRead(thread_id_t thread, const void *location, ui } if (__builtin_popcount(copytoindex) <= 1) { - if (copytoindex == 0) { + if (copytoindex == 0 && record->thread == NULL) { 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); @@ -683,17 +674,81 @@ void atomraceCheckRead(thread_id_t thread, const void *location) { /* 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); + } +} + +static inline uint64_t * raceCheckRead_firstIt(thread_id_t thread, const void * location, uint64_t *old_val, uint64_t *new_val) +{ + uint64_t *shadow = lookupAddressEntry(location); + uint64_t shadowval = *shadow; + + ClockVector *currClock = get_execution()->get_cv(thread); + if (currClock == NULL) + return shadow; + + struct DataRace * race = NULL; + + /* Do full record */ + if (shadowval != 0 && !ISSHORTRECORD(shadowval)) { + race = fullRaceCheckRead(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 = 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); + } + + 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); + struct RaceRecord *record = (struct RaceRecord *) (*shadow); + record->thread[1] = thread; + record->readClock[1] = ourClock; + record->numReads++; + goto Exit; } + *shadow = ENCODEOP(threadid, ourClock, id_to_int(writeThread), writeClock) | (shadowval & ATOMICMASK); + *old_val = shadowval; + *new_val = *shadow; } Exit: if (race) { @@ -702,4 +757,395 @@ Exit: assert_race(race); else model_free(race); } + + return shadow; +} + +static inline void raceCheckRead_otherIt(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 = fullRaceCheckRead(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 = 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); + } + + 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); + struct RaceRecord *record = (struct RaceRecord *) (*shadow); + record->thread[1] = thread; + record->readClock[1] = ourClock; + record->numReads++; + + 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); + } +} + +void raceCheckRead64(thread_id_t thread, const void *location) +{ + uint64_t old_shadowval, new_shadowval; + old_shadowval = new_shadowval = INVALIDSHADOWVAL; + + uint64_t * shadow = raceCheckRead_firstIt(thread, location, &old_shadowval, &new_shadowval); + if (CHECKBOUNDARY(location, 7)) { + if (shadow[1]==old_shadowval) + shadow[1] = new_shadowval; + else goto L1; + if (shadow[2]==old_shadowval) + shadow[2] = new_shadowval; + else goto L2; + if (shadow[3]==old_shadowval) + shadow[3] = new_shadowval; + else goto L3; + if (shadow[4]==old_shadowval) + shadow[4] = new_shadowval; + else goto L4; + if (shadow[5]==old_shadowval) + shadow[5] = new_shadowval; + else goto L5; + if (shadow[6]==old_shadowval) + shadow[6] = new_shadowval; + else goto L6; + if (shadow[7]==old_shadowval) + shadow[7] = new_shadowval; + else goto L7; + return; + } + +L1: + raceCheckRead_otherIt(thread, (const void *)(((uintptr_t)location) + 1)); +L2: + raceCheckRead_otherIt(thread, (const void *)(((uintptr_t)location) + 2)); +L3: + raceCheckRead_otherIt(thread, (const void *)(((uintptr_t)location) + 3)); +L4: + raceCheckRead_otherIt(thread, (const void *)(((uintptr_t)location) + 4)); +L5: + raceCheckRead_otherIt(thread, (const void *)(((uintptr_t)location) + 5)); +L6: + raceCheckRead_otherIt(thread, (const void *)(((uintptr_t)location) + 6)); +L7: + raceCheckRead_otherIt(thread, (const void *)(((uintptr_t)location) + 7)); +} + +void raceCheckRead32(thread_id_t thread, const void *location) +{ + uint64_t old_shadowval, new_shadowval; + old_shadowval = new_shadowval = INVALIDSHADOWVAL; + + uint64_t * shadow = raceCheckRead_firstIt(thread, location, &old_shadowval, &new_shadowval); + if (CHECKBOUNDARY(location, 3)) { + if (shadow[1]==old_shadowval) + shadow[1] = new_shadowval; + else goto L1; + if (shadow[2]==old_shadowval) + shadow[2] = new_shadowval; + else goto L2; + if (shadow[3]==old_shadowval) + shadow[3] = new_shadowval; + else goto L3; + return; + } + +L1: + raceCheckRead_otherIt(thread, (const void *)(((uintptr_t)location) + 1)); +L2: + raceCheckRead_otherIt(thread, (const void *)(((uintptr_t)location) + 2)); +L3: + raceCheckRead_otherIt(thread, (const void *)(((uintptr_t)location) + 3)); +} + +void raceCheckRead16(thread_id_t thread, const void *location) +{ + uint64_t old_shadowval, new_shadowval; + old_shadowval = new_shadowval = INVALIDSHADOWVAL; + + + uint64_t * shadow = raceCheckRead_firstIt(thread, location, &old_shadowval, &new_shadowval); + if (CHECKBOUNDARY(location, 1)) { + if (shadow[1]==old_shadowval) { + shadow[1] = new_shadowval; + return; + } + } + raceCheckRead_otherIt(thread, (const void *)(((uintptr_t)location) + 1)); +} + +void raceCheckRead8(thread_id_t thread, const void *location) +{ + uint64_t old_shadowval, new_shadowval; + old_shadowval = new_shadowval = INVALIDSHADOWVAL; + + raceCheckRead_firstIt(thread, location, &old_shadowval, &new_shadowval); +} + +static inline uint64_t * raceCheckWrite_firstIt(thread_id_t thread, const void * location, uint64_t *old_val, uint64_t *new_val) +{ + uint64_t *shadow = lookupAddressEntry(location); + uint64_t shadowval = *shadow; + ClockVector *currClock = get_execution()->get_cv(thread); + if (currClock == NULL) + return shadow; + + struct DataRace * race = NULL; + /* Do full record */ + if (shadowval != 0 && !ISSHORTRECORD(shadowval)) { + 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); + + *old_val = shadowval; + *new_val = *shadow; + } + +Exit: + if (race) { + race->numframes=backtrace(race->backtrace, sizeof(race->backtrace)/sizeof(void*)); + if (raceset->add(race)) + assert_race(race); + else model_free(race); + } + + return shadow; +} + +static inline void raceCheckWrite_otherIt(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 = 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); + } +} + +void raceCheckWrite64(thread_id_t thread, const void *location) +{ + uint64_t old_shadowval, new_shadowval; + old_shadowval = new_shadowval = INVALIDSHADOWVAL; + + uint64_t * shadow = raceCheckWrite_firstIt(thread, location, &old_shadowval, &new_shadowval); + if (CHECKBOUNDARY(location, 7)) { + if (shadow[1]==old_shadowval) + shadow[1] = new_shadowval; + else goto L1; + if (shadow[2]==old_shadowval) + shadow[2] = new_shadowval; + else goto L2; + if (shadow[3]==old_shadowval) + shadow[3] = new_shadowval; + else goto L3; + if (shadow[4]==old_shadowval) + shadow[4] = new_shadowval; + else goto L4; + if (shadow[5]==old_shadowval) + shadow[5] = new_shadowval; + else goto L5; + if (shadow[6]==old_shadowval) + shadow[6] = new_shadowval; + else goto L6; + if (shadow[7]==old_shadowval) + shadow[7] = new_shadowval; + else goto L7; + return; + } + +L1: + raceCheckWrite_otherIt(thread, (const void *)(((uintptr_t)location) + 1)); +L2: + raceCheckWrite_otherIt(thread, (const void *)(((uintptr_t)location) + 2)); +L3: + raceCheckWrite_otherIt(thread, (const void *)(((uintptr_t)location) + 3)); +L4: + raceCheckWrite_otherIt(thread, (const void *)(((uintptr_t)location) + 4)); +L5: + raceCheckWrite_otherIt(thread, (const void *)(((uintptr_t)location) + 5)); +L6: + raceCheckWrite_otherIt(thread, (const void *)(((uintptr_t)location) + 6)); +L7: + raceCheckWrite_otherIt(thread, (const void *)(((uintptr_t)location) + 7)); +} + +void raceCheckWrite32(thread_id_t thread, const void *location) +{ + uint64_t old_shadowval, new_shadowval; + old_shadowval = new_shadowval = INVALIDSHADOWVAL; + + uint64_t * shadow = raceCheckWrite_firstIt(thread, location, &old_shadowval, &new_shadowval); + if (CHECKBOUNDARY(location, 3)) { + if (shadow[1]==old_shadowval) + shadow[1] = new_shadowval; + else goto L1; + if (shadow[2]==old_shadowval) + shadow[2] = new_shadowval; + else goto L2; + if (shadow[3]==old_shadowval) + shadow[3] = new_shadowval; + else goto L3; + return; + } + +L1: + raceCheckWrite_otherIt(thread, (const void *)(((uintptr_t)location) + 1)); +L2: + raceCheckWrite_otherIt(thread, (const void *)(((uintptr_t)location) + 2)); +L3: + raceCheckWrite_otherIt(thread, (const void *)(((uintptr_t)location) + 3)); +} + +void raceCheckWrite16(thread_id_t thread, const void *location) +{ + uint64_t old_shadowval, new_shadowval; + old_shadowval = new_shadowval = INVALIDSHADOWVAL; + + uint64_t * shadow = raceCheckWrite_firstIt(thread, location, &old_shadowval, &new_shadowval); + if (CHECKBOUNDARY(location, 1)) { + if (shadow[1]==old_shadowval) { + shadow[1] = new_shadowval; + return; + } + } + raceCheckWrite_otherIt(thread, (const void *)(((uintptr_t)location) + 1)); +} + +void raceCheckWrite8(thread_id_t thread, const void *location) +{ + uint64_t old_shadowval, new_shadowval; + old_shadowval = new_shadowval = INVALIDSHADOWVAL; + + raceCheckWrite_firstIt(thread, location, &old_shadowval, &new_shadowval); }