More code towards support non-atomic stores

[c11tester.git] / datarace.cc

diff --git a/datarace.cc b/datarace.cc
index b3ce8abe75b1ce9a59d9e5a883d45980a4cbdb41..58c52dd63c7a80baf27f3017cc4c195054a8f524 100644 (file)
--- a/datarace.cc
+++ b/datarace.cc
@@ -60,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.
@@ -93,14 +135,15 @@ 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;
 }
 
@@ -149,11 +192,11 @@ static struct DataRace * reportDataRace(thread_id_t oldthread, modelclock_t oldc
  */
 void assert_race(struct DataRace *race)
 {
-       model_print("At location: \n");
+       model_print("Race detected at location: \n");
        backtrace_symbols_fd(race->backtrace, race->numframes, model_out);
-       model_print("Data race detected @ address %p:\n"
+       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",
+                                                       "    Access 2: %5s in thread %2d @ clock %3u\n\n",
                                                        race->address,
                                                        race->isoldwrite ? "write" : "read",
                                                        id_to_int(race->oldthread),
@@ -201,6 +244,7 @@ struct DataRace * fullRaceCheckWrite(thread_id_t thread, void *location, uint64_
 Exit:
        record->numReads = 0;
        record->writeThread = thread;
+       record->isAtomic = 0;
        modelclock_t ourClock = currClock->getClock(thread);
        record->writeClock = ourClock;
        return race;
@@ -278,6 +322,7 @@ void fullRecordWrite(thread_id_t thread, void *location, uint64_t *shadow, Clock
        record->writeThread = thread;
        modelclock_t ourClock = currClock->getClock(thread);
        record->writeClock = ourClock;
+       record->isAtomic = 1;
 }
 
 /** This function just updates metadata on atomic write. */
@@ -301,7 +346,7 @@ void recordWrite(thread_id_t thread, void *location) {
                return;
        }
 
-       *shadow = ENCODEOP(0, 0, threadid, ourClock);
+       *shadow = ENCODEOP(0, 0, threadid, ourClock) | ATOMICMASK;
 }
 
 
@@ -346,23 +391,21 @@ struct DataRace * fullRaceCheckRead(thread_id_t thread, const void *location, ui
                }
        }
 
-       if (copytoindex >= record->capacity) {
-               if (record->capacity == 0) {
+       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);
-                       record->capacity = newCapacity;
-               } else {
-                       int newCapacity = record->capacity * 2;
+               } 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, record->capacity * sizeof(thread_id_t));
-                       std::memcpy(newreadClock, record->readClock, record->capacity * sizeof(modelclock_t));
+                       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;
-                       record->capacity = newCapacity;
                }
        }
 
@@ -424,7 +467,7 @@ ShadowExit:
                        }
                }
 
-               *shadow = ENCODEOP(threadid, ourClock, id_to_int(writeThread), writeClock);
+               *shadow = ENCODEOP(threadid, ourClock, id_to_int(writeThread), writeClock) | (shadowval & ATOMICMASK);
        }
 Exit:
        if (race) {