#include "datarace.h"
+#include "model.h"
#include "threads.h"
#include <stdio.h>
#include <cstring>
struct ShadowTable *root;
+std::vector<struct DataRace *> unrealizedraces;
/** This function initialized the data race detector. */
void initRaceDetector() {
}
/** This function is called when we detect a data race.*/
-static void reportDataRace() {
- printf("The reportDataRace method should report useful things about this datarace!\n");
+static void reportDataRace(thread_id_t oldthread, modelclock_t oldclock, bool isoldwrite, ModelAction *newaction, bool isnewwrite, void *address) {
+ struct DataRace * race=(struct DataRace *)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);
+ checkDataRaces();
+}
+
+/** This function goes through the list of unrealized data races,
+ * removes the impossible ones, and print the realized ones. */
+
+void checkDataRaces() {
+ if (true) {
+ /* Prune the non-racing unrealized dataraces */
+ unsigned int i,newloc=0;
+ for(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)) {
+ unrealizedraces[newloc++]=race;
+ }
+ }
+ if (newloc!=i)
+ unrealizedraces.resize(newloc);
+ for(i=0;i<unrealizedraces.size();i++) {
+ struct DataRace * race=unrealizedraces[i];
+ printRace(race);
+ }
+ }
+}
+
+void printRace(struct DataRace * race) {
+ printf("Datarace detected\n");
+ printf("Location %p\n", race->address);
+ printf("Initial access: thread %u clock %u, iswrite %u\n",race->oldthread,race->oldclock, race->isoldwrite);
+ printf("Second access: thread %u, iswrite %u\n", race->newaction->get_tid(), race->isnewwrite);
}
/** This function does race detection for a write on an expanded record. */
-void fullRaceCheckWrite(thread_id_t thread, uint64_t * shadow, ClockVector *currClock) {
+void fullRaceCheckWrite(thread_id_t thread, void *location, uint64_t * shadow, ClockVector *currClock) {
struct RaceRecord * record=(struct RaceRecord *) (*shadow);
/* Check for datarace against last read. */
if (clock_may_race(currClock, thread, readClock, readThread)) {
/* We have a datarace */
- reportDataRace();
+ reportDataRace(readThread, readClock, false, model->get_parent_action(thread), true, location);
}
}
if (clock_may_race(currClock, thread, writeClock, writeThread)) {
/* We have a datarace */
- reportDataRace();
+ reportDataRace(writeThread, writeClock, true, model->get_parent_action(thread), true, location);
}
record->numReads=0;
/* Do full record */
if (shadowval!=0&&!ISSHORTRECORD(shadowval)) {
- fullRaceCheckWrite(thread, shadow, currClock);
+ fullRaceCheckWrite(thread, location, shadow, currClock);
return;
}
/* Thread ID is too large or clock is too large. */
if (threadid > MAXTHREADID || ourClock > MAXWRITEVECTOR) {
expandRecord(shadow);
- fullRaceCheckWrite(thread, shadow, currClock);
+ fullRaceCheckWrite(thread, location, shadow, currClock);
return;
}
if (clock_may_race(currClock, thread, readClock, readThread)) {
/* We have a datarace */
- reportDataRace();
+ reportDataRace(readThread, readClock, false, model->get_parent_action(thread), true, location);
}
/* Check for datarace against last write. */
if (clock_may_race(currClock, thread, writeClock, writeThread)) {
/* We have a datarace */
- reportDataRace();
+ reportDataRace(writeThread, writeClock, true, model->get_parent_action(thread), true, location);
}
*shadow = ENCODEOP(0, 0, threadid, ourClock);
}
/** This function does race detection on a read for an expanded record. */
-void fullRaceCheckRead(thread_id_t thread, uint64_t * shadow, ClockVector *currClock) {
+void fullRaceCheckRead(thread_id_t thread, void *location, uint64_t * shadow, ClockVector *currClock) {
struct RaceRecord * record=(struct RaceRecord *) (*shadow);
/* Check for datarace against last write. */
if (clock_may_race(currClock, thread, writeClock, writeThread)) {
/* We have a datarace */
- reportDataRace();
+ reportDataRace(writeThread, writeClock, true, model->get_parent_action(thread), false, location);
}
/* Shorten vector when possible */
/* Do full record */
if (shadowval!=0&&!ISSHORTRECORD(shadowval)) {
- fullRaceCheckRead(thread, shadow, currClock);
+ fullRaceCheckRead(thread, location, shadow, currClock);
return;
}
/* Thread ID is too large or clock is too large. */
if (threadid > MAXTHREADID || ourClock > MAXWRITEVECTOR) {
expandRecord(shadow);
- fullRaceCheckRead(thread, shadow, currClock);
+ fullRaceCheckRead(thread, location, shadow, currClock);
return;
}
if (clock_may_race(currClock, thread, writeClock, writeThread)) {
/* We have a datarace */
- reportDataRace();
+ reportDataRace(writeThread, writeClock, true, model->get_parent_action(thread), false, location);
}
modelclock_t readClock = READVECTOR(shadowval);
if (clock_may_race(currClock, thread, readClock, readThread)) {
/* We don't subsume this read... Have to expand record. */
expandRecord(shadow);
- fullRaceCheckRead(thread, shadow, currClock);
+ fullRaceCheckRead(thread, location, shadow, currClock);
return;
}
- *shadow = ENCODEOP(writeThread, writeClock, threadid, ourClock);
+ *shadow = ENCODEOP(threadid, ourClock, id_to_int(writeThread), writeClock);
}
--- /dev/null
+#include <stdio.h>
+
+#include "libthreads.h"
+#include "librace.h"
+#include "stdatomic.h"
+
+
+#define RW_LOCK_BIAS 0x00100000
+#define WRITE_LOCK_CMP RW_LOCK_BIAS
+
+/** Example implementation of linux rw lock along with 2 thread test
+ * driver... */
+
+
+typedef union {
+ atomic_int lock;
+} rwlock_t;
+
+static inline int read_can_lock(rwlock_t *lock)
+{
+ return atomic_load_explicit(&lock->lock, memory_order_relaxed) > 0;
+}
+
+static inline int write_can_lock(rwlock_t *lock)
+{
+ return atomic_load_explicit(&lock->lock, memory_order_relaxed) == RW_LOCK_BIAS;
+}
+
+static inline void read_lock(rwlock_t *rw)
+{
+ int currentvalue=atomic_fetch_sub_explicit(&rw->lock, 1, memory_order_acquire);
+ while (currentvalue<0) {
+ atomic_fetch_add_explicit(&rw->lock, 1, memory_order_relaxed);
+ do {
+ currentvalue=atomic_load_explicit(&rw->lock, memory_order_relaxed);
+ } while(currentvalue<=0);
+ currentvalue=atomic_fetch_sub_explicit(&rw->lock, 1, memory_order_acquire);
+ }
+}
+
+static inline void write_lock(rwlock_t *rw)
+{
+ int currentvalue=atomic_fetch_sub_explicit(&rw->lock, RW_LOCK_BIAS, memory_order_acquire);
+ while (currentvalue!=0) {
+ atomic_fetch_add_explicit(&rw->lock, RW_LOCK_BIAS, memory_order_relaxed);
+ do {
+ currentvalue=atomic_load_explicit(&rw->lock, memory_order_relaxed);
+ } while(currentvalue!=RW_LOCK_BIAS);
+ currentvalue=atomic_fetch_sub_explicit(&rw->lock, RW_LOCK_BIAS, memory_order_acquire);
+ }
+}
+
+static inline int read_trylock(rwlock_t *rw)
+{
+ int currentvalue=atomic_fetch_sub_explicit(&rw->lock, 1, memory_order_acquire);
+ if (currentvalue>=0)
+ return 1;
+
+ atomic_fetch_add_explicit(&rw->lock, 1, memory_order_relaxed);
+ return 0;
+}
+
+static inline int write_trylock(rwlock_t *rw)
+{
+ int currentvalue=atomic_fetch_sub_explicit(&rw->lock, RW_LOCK_BIAS, memory_order_acquire);
+ if (currentvalue>=0)
+ return 1;
+
+ atomic_fetch_add_explicit(&rw->lock, RW_LOCK_BIAS, memory_order_relaxed);
+ return 0;
+}
+
+static inline void read_unlock(rwlock_t *rw)
+{
+ atomic_fetch_add_explicit(&rw->lock, 1, memory_order_release);
+}
+
+static inline void write_unlock(rwlock_t *rw)
+{
+ atomic_fetch_add_explicit(&rw->lock, RW_LOCK_BIAS, memory_order_release);
+}
+
+rwlock_t mylock;
+int shareddata;
+
+static void a(void *obj)
+{
+ int i;
+ for(i=0;i<2;i++) {
+ if ((i%2)==0) {
+ read_lock(&mylock);
+ load_32(&shareddata);
+ read_unlock(&mylock);
+ } else {
+ write_lock(&mylock);
+ store_32(&shareddata,(unsigned int)i);
+ write_unlock(&mylock);
+ }
+ }
+}
+
+void user_main()
+{
+ thrd_t t1, t2;
+ atomic_init(&mylock.lock, RW_LOCK_BIAS);
+
+ printf("Thread %d: creating 2 threads\n", thrd_current());
+ thrd_create(&t1, (thrd_start_t)&a, NULL);
+ thrd_create(&t2, (thrd_start_t)&a, NULL);
+
+ thrd_join(t1);
+ thrd_join(t2);
+ printf("Thread %d is finished\n", thrd_current());
+}