Change initialize a bit

[c11tester.git] / datarace.cc

diff --git a/datarace.cc b/datarace.cc
index 0bfaaff70b0b91efefc5bff7c68cdd705428a3b7..9c403668e90d7c0fbe6ff76cda3cc3f1a2c37d81 100644 (file)
--- a/datarace.cc
+++ b/datarace.cc
@@ -16,6 +16,18 @@ static void *memory_base;
 static void *memory_top;
 static RaceSet * raceset;
 
+#ifdef COLLECT_STAT
+static unsigned int store8_count = 0;
+static unsigned int store16_count = 0;
+static unsigned int store32_count = 0;
+static unsigned int store64_count = 0;
+
+static unsigned int load8_count = 0;
+static unsigned int load16_count = 0;
+static unsigned int load32_count = 0;
+static unsigned int load64_count = 0;
+#endif
+
 static const ModelExecution * get_execution()
 {
        return model->get_execution();
@@ -43,7 +55,7 @@ void * table_calloc(size_t size)
 
 /** This function looks up the entry in the shadow table corresponding to a
  * given address.*/
-static uint64_t * lookupAddressEntry(const void *address)
+static inline uint64_t * lookupAddressEntry(const void *address)
 {
        struct ShadowTable *currtable = root;
 #if BIT48
@@ -143,6 +155,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 +174,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;
@@ -174,6 +187,7 @@ bool race_equals(struct DataRace *r1, struct DataRace *r2) {
 /** This function is called when we detect a data race.*/
 static struct DataRace * reportDataRace(thread_id_t oldthread, modelclock_t oldclock, bool isoldwrite, ModelAction *newaction, bool isnewwrite, const void *address)
 {
+#ifdef REPORT_DATA_RACES
        struct DataRace *race = (struct DataRace *)model_malloc(sizeof(struct DataRace));
        race->oldthread = oldthread;
        race->oldclock = oldclock;
@@ -182,6 +196,9 @@ static struct DataRace * reportDataRace(thread_id_t oldthread, modelclock_t oldc
        race->isnewwrite = isnewwrite;
        race->address = address;
        return race;
+#else
+       return NULL;
+#endif
 }
 
 /**
@@ -232,7 +249,6 @@ struct DataRace * fullRaceCheckWrite(thread_id_t thread, const void *location, u
        }
 
        /* Check for datarace against last write. */
-
        {
                modelclock_t writeClock = record->writeClock;
                thread_id_t writeThread = record->writeThread;
@@ -279,8 +295,6 @@ void raceCheckWrite(thread_id_t thread, void *location)
                        goto Exit;
                }
 
-
-
                {
                        /* Check for datarace against last read. */
                        modelclock_t readClock = READVECTOR(shadowval);
@@ -295,7 +309,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));
 
@@ -312,14 +325,17 @@ ShadowExit:
 
 Exit:
        if (race) {
+#ifdef REPORT_DATA_RACES
                race->numframes=backtrace(race->backtrace, sizeof(race->backtrace)/sizeof(void*));
                if (raceset->add(race))
                        assert_race(race);
                else model_free(race);
+#else
+               model_free(race);
+#endif
        }
 }
 
-
 /** This function does race detection for a write on an expanded record. */
 struct DataRace * atomfullRaceCheckWrite(thread_id_t thread, const void *location, uint64_t *shadow, ClockVector *currClock)
 {
@@ -399,7 +415,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));
 
@@ -412,7 +427,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));
 
@@ -429,10 +443,14 @@ ShadowExit:
 
 Exit:
        if (race) {
+#ifdef REPORT_DATA_RACES
                race->numframes=backtrace(race->backtrace, sizeof(race->backtrace)/sizeof(void*));
                if (raceset->add(race))
                        assert_race(race);
                else model_free(race);
+#else
+               model_free(race);
+#endif
        }
 }
 
@@ -482,7 +500,7 @@ void recordWrite(thread_id_t thread, void *location) {
 
 /** This function just updates metadata on atomic write. */
 void recordCalloc(void *location, size_t size) {
-       thread_id_t thread = thread_current()->get_id();
+       thread_id_t thread = thread_current_id();
        for(;size != 0;size--) {
                uint64_t *shadow = lookupAddressEntry(location);
                uint64_t shadowval = *shadow;
@@ -508,8 +526,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)
 {
@@ -542,16 +558,16 @@ struct DataRace * fullRaceCheckRead(thread_id_t thread, const void *location, ui
                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];
+                               ASSERT(readThread >= 0);
+                               record->readClock[copytoindex] = readClock;
+                               record->thread[copytoindex] = readThread;
                        }
                        copytoindex++;
                }
        }
 
        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);
@@ -633,10 +649,14 @@ ShadowExit:
        }
 Exit:
        if (race) {
+#ifdef REPORT_DATA_RACES
                race->numframes=backtrace(race->backtrace, sizeof(race->backtrace)/sizeof(void*));
                if (raceset->add(race))
                        assert_race(race);
                else model_free(race);
+#else
+               model_free(race);
+#endif
        }
 }
 
@@ -682,7 +702,6 @@ 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));
 
@@ -696,10 +715,14 @@ void atomraceCheckRead(thread_id_t thread, const void *location)
        }
 Exit:
        if (race) {
+#ifdef REPORT_DATA_RACES
                race->numframes=backtrace(race->backtrace, sizeof(race->backtrace)/sizeof(void*));
                if (raceset->add(race))
                        assert_race(race);
                else model_free(race);
+#else
+               model_free(race);
+#endif
        }
 }
 
@@ -732,7 +755,6 @@ static inline uint64_t * raceCheckRead_firstIt(thread_id_t thread, const void *
                }
 
                /* Check for datarace against last write. */
-
                modelclock_t writeClock = WRITEVECTOR(shadowval);
                thread_id_t writeThread = int_to_id(WRTHREADID(shadowval));
 
@@ -762,10 +784,14 @@ static inline uint64_t * raceCheckRead_firstIt(thread_id_t thread, const void *
        }
 Exit:
        if (race) {
+#ifdef REPORT_DATA_RACES
                race->numframes=backtrace(race->backtrace, sizeof(race->backtrace)/sizeof(void*));
                if (raceset->add(race))
                        assert_race(race);
                else model_free(race);
+#else
+               model_free(race);
+#endif
        }
 
        return shadow;
@@ -826,21 +852,24 @@ static inline void raceCheckRead_otherIt(thread_id_t thread, const void * locati
        }
 Exit:
        if (race) {
+#ifdef REPORT_DATA_RACES
                race->numframes=backtrace(race->backtrace, sizeof(race->backtrace)/sizeof(void*));
                if (raceset->add(race))
                        assert_race(race);
                else model_free(race);
+#else
+               model_free(race);
+#endif
        }
 }
 
-
-
 void raceCheckRead64(thread_id_t thread, const void *location)
 {
        uint64_t old_shadowval, new_shadowval;
        old_shadowval = new_shadowval = INVALIDSHADOWVAL;
-
-
+#ifdef COLLECT_STAT
+       load64_count++;
+#endif
        uint64_t * shadow = raceCheckRead_firstIt(thread, location, &old_shadowval, &new_shadowval);
        if (CHECKBOUNDARY(location, 7)) {
                if (shadow[1]==old_shadowval)
@@ -887,8 +916,9 @@ void raceCheckRead32(thread_id_t thread, const void *location)
 {
        uint64_t old_shadowval, new_shadowval;
        old_shadowval = new_shadowval = INVALIDSHADOWVAL;
-
-
+#ifdef COLLECT_STAT
+       load32_count++;
+#endif
        uint64_t * shadow = raceCheckRead_firstIt(thread, location, &old_shadowval, &new_shadowval);
        if (CHECKBOUNDARY(location, 3)) {
                if (shadow[1]==old_shadowval)
@@ -915,8 +945,9 @@ void raceCheckRead16(thread_id_t thread, const void *location)
 {
        uint64_t old_shadowval, new_shadowval;
        old_shadowval = new_shadowval = INVALIDSHADOWVAL;
-
-
+#ifdef COLLECT_STAT
+       load16_count++;
+#endif
        uint64_t * shadow = raceCheckRead_firstIt(thread, location, &old_shadowval, &new_shadowval);
        if (CHECKBOUNDARY(location, 1)) {
                if (shadow[1]==old_shadowval) {
@@ -931,8 +962,9 @@ void raceCheckRead8(thread_id_t thread, const void *location)
 {
        uint64_t old_shadowval, new_shadowval;
        old_shadowval = new_shadowval = INVALIDSHADOWVAL;
-
-
+#ifdef COLLECT_STAT
+       load8_count++;
+#endif
        raceCheckRead_firstIt(thread, location, &old_shadowval, &new_shadowval);
 }
 
@@ -995,10 +1027,14 @@ ShadowExit:
 
 Exit:
        if (race) {
+#ifdef REPORT_DATA_RACES
                race->numframes=backtrace(race->backtrace, sizeof(race->backtrace)/sizeof(void*));
                if (raceset->add(race))
                        assert_race(race);
                else model_free(race);
+#else
+               model_free(race);
+#endif
        }
 
        return shadow;
@@ -1061,10 +1097,14 @@ ShadowExit:
 
 Exit:
        if (race) {
+#ifdef REPORT_DATA_RACES
                race->numframes=backtrace(race->backtrace, sizeof(race->backtrace)/sizeof(void*));
                if (raceset->add(race))
                        assert_race(race);
                else model_free(race);
+#else
+               model_free(race);
+#endif
        }
 }
 
@@ -1072,8 +1112,9 @@ void raceCheckWrite64(thread_id_t thread, const void *location)
 {
        uint64_t old_shadowval, new_shadowval;
        old_shadowval = new_shadowval = INVALIDSHADOWVAL;
-
-
+#ifdef COLLECT_STAT
+       store64_count++;
+#endif
        uint64_t * shadow = raceCheckWrite_firstIt(thread, location, &old_shadowval, &new_shadowval);
        if (CHECKBOUNDARY(location, 7)) {
                if (shadow[1]==old_shadowval)
@@ -1120,8 +1161,9 @@ void raceCheckWrite32(thread_id_t thread, const void *location)
 {
        uint64_t old_shadowval, new_shadowval;
        old_shadowval = new_shadowval = INVALIDSHADOWVAL;
-
-
+#ifdef COLLECT_STAT
+       store32_count++;
+#endif
        uint64_t * shadow = raceCheckWrite_firstIt(thread, location, &old_shadowval, &new_shadowval);
        if (CHECKBOUNDARY(location, 3)) {
                if (shadow[1]==old_shadowval)
@@ -1148,7 +1190,9 @@ void raceCheckWrite16(thread_id_t thread, const void *location)
 {
        uint64_t old_shadowval, new_shadowval;
        old_shadowval = new_shadowval = INVALIDSHADOWVAL;
-
+#ifdef COLLECT_STAT
+       store16_count++;
+#endif
 
        uint64_t * shadow = raceCheckWrite_firstIt(thread, location, &old_shadowval, &new_shadowval);
        if (CHECKBOUNDARY(location, 1)) {
@@ -1164,7 +1208,23 @@ void raceCheckWrite8(thread_id_t thread, const void *location)
 {
        uint64_t old_shadowval, new_shadowval;
        old_shadowval = new_shadowval = INVALIDSHADOWVAL;
-
-
+#ifdef COLLECT_STAT
+       store8_count++;
+#endif
        raceCheckWrite_firstIt(thread, location, &old_shadowval, &new_shadowval);
 }
+
+#ifdef COLLECT_STAT
+void print_normal_accesses()
+{
+       model_print("store 8  count: %u\n", store8_count);
+       model_print("store 16 count: %u\n", store16_count);
+       model_print("store 32 count: %u\n", store32_count);
+       model_print("store 64 count: %u\n", store64_count);
+
+       model_print("load  8  count: %u\n", load8_count);
+       model_print("load  16 count: %u\n", load16_count);
+       model_print("load  32 count: %u\n", load32_count);
+       model_print("load  64 count: %u\n", load64_count);
+}
+#endif