X-Git-Url: http://plrg.eecs.uci.edu/git/?p=c11tester.git;a=blobdiff_plain;f=datarace.h;h=f026556add051292ea4c57daaac4ad42255f1576;hp=a8f0ba323c05df01937e0b953c5b0e8abd22a70d;hb=9cf7a4cf4ce3caa33c27b4211db3d987a6b103ec;hpb=38c72a8748ae74a5bb8b75e713f363a49b48e7af diff --git a/datarace.h b/datarace.h index a8f0ba32..f026556a 100644 --- a/datarace.h +++ b/datarace.h @@ -9,6 +9,7 @@ #include #include "modeltypes.h" #include "classlist.h" +#include "hashset.h" struct ShadowTable { void * array[65536]; @@ -20,7 +21,7 @@ struct ShadowBaseTable { struct DataRace { /* Clock and thread associated with first action. This won't change in - response to synchronization. */ + response to synchronization. */ thread_id_t oldthread; modelclock_t oldclock; @@ -28,23 +29,30 @@ struct DataRace { bool isoldwrite; /* Model action associated with second action. This could change as - a result of synchronization. */ + a result of synchronization. */ ModelAction *newaction; /* Record whether this is a write, so we can tell the user. */ bool isnewwrite; /* Address of data race. */ const void *address; + void * backtrace[64]; + int numframes; }; #define MASK16BIT 0xffff void initRaceDetector(); void raceCheckWrite(thread_id_t thread, void *location); +void atomraceCheckWrite(thread_id_t thread, void *location); void raceCheckRead(thread_id_t thread, const void *location); -bool checkDataRaces(); +void atomraceCheckRead(thread_id_t thread, const void *location); +void recordWrite(thread_id_t thread, void *location); +void recordCalloc(void *location, size_t size); void assert_race(struct DataRace *race); -bool haveUnrealizedRaces(); +bool hasNonAtomicStore(const void *location); +void setAtomicStoreFlag(const void *location); +void getStoreThreadAndClock(const void *address, thread_id_t * thread, modelclock_t * clock); /** * @brief A record of information for detecting data races @@ -52,25 +60,31 @@ bool haveUnrealizedRaces(); struct RaceRecord { modelclock_t *readClock; thread_id_t *thread; - int capacity; - int numReads; + int numReads : 31; + int isAtomic : 1; thread_id_t writeThread; modelclock_t writeClock; }; +unsigned int race_hash(struct DataRace *race); +bool race_equals(struct DataRace *r1, struct DataRace *r2); + #define INITCAPACITY 4 #define ISSHORTRECORD(x) ((x)&0x1) -#define THREADMASK 0xff +#define THREADMASK 0x3f #define RDTHREADID(x) (((x)>>1)&THREADMASK) -#define READMASK 0x07fffff -#define READVECTOR(x) (((x)>>9)&READMASK) +#define READMASK 0x1ffffff +#define READVECTOR(x) (((x)>>7)&READMASK) #define WRTHREADID(x) (((x)>>32)&THREADMASK) #define WRITEMASK READMASK -#define WRITEVECTOR(x) (((x)>>40)&WRITEMASK) +#define WRITEVECTOR(x) (((x)>>38)&WRITEMASK) + +#define ATOMICMASK (0x1ULL << 63) +#define NONATOMICMASK ~(0x1ULL << 63) /** * The basic encoding idea is that (void *) either: @@ -78,15 +92,18 @@ struct RaceRecord { * -# encodes the information in a 64 bit word. Encoding is as * follows: * - lowest bit set to 1 - * - next 8 bits are read thread id - * - next 23 bits are read clock vector - * - next 8 bits are write thread id - * - next 23 bits are write clock vector + * - next 6 bits are read thread id + * - next 25 bits are read clock vector + * - next 6 bits are write thread id + * - next 25 bits are write clock vector + * - highest bit is 1 if the write is from an atomic */ -#define ENCODEOP(rdthread, rdtime, wrthread, wrtime) (0x1ULL | ((rdthread)<<1) | ((rdtime) << 9) | (((uint64_t)wrthread)<<32) | (((uint64_t)wrtime)<<40)) +#define ENCODEOP(rdthread, rdtime, wrthread, wrtime) (0x1ULL | ((rdthread)<<1) | ((rdtime) << 7) | (((uint64_t)wrthread)<<32) | (((uint64_t)wrtime)<<38)) #define MAXTHREADID (THREADMASK-1) #define MAXREADVECTOR (READMASK-1) #define MAXWRITEVECTOR (WRITEMASK-1) -#endif /* __DATARACE_H__ */ +typedef HashSet RaceSet; + +#endif /* __DATARACE_H__ */