X-Git-Url: http://plrg.eecs.uci.edu/git/?p=c11tester.git;a=blobdiff_plain;f=datarace.cc;h=d6e0875c1a5562315b26367a3582452d5c41b07d;hp=5ab52fc49eefa87ea1d2ad4e3c8c1a4b607f15f5;hb=bbc3405aa23e6eafb3863738c4e203764694e9a4;hpb=620c53f1b91d3f9b51424ff57c652d247f6fbaac

diff --git a/datarace.cc b/datarace.cc
index 5ab52fc4..d6e0875c 100644
--- a/datarace.cc
+++ b/datarace.cc
@@ -3,13 +3,15 @@
 #include "threads.h"
 #include <stdio.h>
 #include <cstring>
+#include "mymemory.h"
+#include "clockvector.h"
 
 struct ShadowTable *root;
 std::vector<struct DataRace *> unrealizedraces;
 
 /** This function initialized the data race detector. */
 void initRaceDetector() {
-	root=(struct ShadowTable *) calloc(sizeof(struct ShadowTable),1);
+	root = (struct ShadowTable *)snapshot_calloc(sizeof(struct ShadowTable), 1);
 }
 
 /** This function looks up the entry in the shadow table corresponding to a
@@ -19,13 +21,13 @@ static uint64_t * lookupAddressEntry(void * address) {
 #if BIT48
 	currtable=(struct ShadowTable *) currtable->array[(((uintptr_t)address)>>32)&MASK16BIT];
 	if (currtable==NULL) {
-		currtable=(struct ShadowTable *) (root->array[(((uintptr_t)address)>>32)&MASK16BIT]=calloc(sizeof(struct ShadowTable),1));
+		currtable = (struct ShadowTable *)(root->array[(((uintptr_t)address)>>32)&MASK16BIT] = snapshot_calloc(sizeof(struct ShadowTable), 1));
 	}
 #endif
 
 	struct ShadowBaseTable * basetable=(struct ShadowBaseTable *) currtable->array[(((uintptr_t)address)>>16)&MASK16BIT];
 	if (basetable==NULL) {
-		basetable=(struct ShadowBaseTable *) (currtable->array[(((uintptr_t)address)>>16)&MASK16BIT]=calloc(sizeof(struct ShadowBaseTable),1));
+		basetable = (struct ShadowBaseTable *)(currtable->array[(((uintptr_t)address)>>16)&MASK16BIT] = snapshot_calloc(sizeof(struct ShadowBaseTable), 1));
 	}
 	return &basetable->array[((uintptr_t)address)&MASK16BIT];
 }
@@ -57,14 +59,14 @@ static void expandRecord(uint64_t * shadow) {
 	modelclock_t writeClock = WRITEVECTOR(shadowval);
 	thread_id_t writeThread = int_to_id(WRTHREADID(shadowval));
 
-	struct RaceRecord * record=(struct RaceRecord *)calloc(1,sizeof(struct RaceRecord));
+	struct RaceRecord *record = (struct RaceRecord *)snapshot_calloc(1, sizeof(struct RaceRecord));
 	record->writeThread=writeThread;
 	record->writeClock=writeClock;
 
 	if (readClock!=0) {
 		record->capacity=INITCAPACITY;
-		record->thread=(thread_id_t *) malloc(sizeof(thread_id_t)*record->capacity);
-		record->readClock=(modelclock_t *) malloc(sizeof(modelclock_t)*record->capacity);
+		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->numReads=1;
 		record->thread[0]=readThread;
 		record->readClock[0]=readClock;
@@ -74,7 +76,7 @@ static void expandRecord(uint64_t * shadow) {
 
 /** This function is called when we detect a data race.*/
 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));
+	struct DataRace *race = (struct DataRace *)snapshot_malloc(sizeof(struct DataRace));
 	race->oldthread=oldthread;
 	race->oldclock=oldclock;
 	race->isoldwrite=isoldwrite;
@@ -82,14 +84,19 @@ static void reportDataRace(thread_id_t oldthread, modelclock_t oldclock, bool is
 	race->isnewwrite=isnewwrite;
 	race->address=address;
 	unrealizedraces.push_back(race);
-	checkDataRaces();
+
+	/* If the race is realized, bail out now. */
+	if (checkDataRaces()) {
+		model->set_assert();
+		model->switch_to_master(NULL);
+	}
 }
 
 /** This function goes through the list of unrealized data races,
  *	removes the impossible ones, and print the realized ones. */
 
-void checkDataRaces() {
-	if (true) {
+bool checkDataRaces() {
+	if (model->isfeasibleprefix()) {
 		/* Prune the non-racing unrealized dataraces */
 		unsigned int i,newloc=0;
 		for(i=0;i<unrealizedraces.size();i++) {
@@ -100,18 +107,24 @@ void checkDataRaces() {
 		}
 		if (newloc!=i)
 			unrealizedraces.resize(newloc);
-		for(i=0;i<unrealizedraces.size();i++) {
-			struct DataRace * race=unrealizedraces[i];
-			printRace(race);
+
+		if (unrealizedraces.size()!=0) {
+			/* We have an actual realized race. */
+			for(i=0;i<unrealizedraces.size();i++) {
+				struct DataRace * race=unrealizedraces[i];
+				printRace(race);
+			}
+			return true;
 		}
 	}
+	return false;
 }
 
 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);
+	printf("Second access: thread %u clock %u, iswrite %u\n", race->newaction->get_tid(), race->newaction->get_seq_number() , race->isnewwrite);
 }
 
 /** This function does race detection for a write on an expanded record. */
@@ -232,12 +245,12 @@ void fullRaceCheckRead(thread_id_t thread, void *location, uint64_t * shadow, Cl
 
 	if (copytoindex>=record->capacity) {
 		int newCapacity=record->capacity*2;
-		thread_id_t *newthread=(thread_id_t *) malloc(sizeof(thread_id_t)*newCapacity);
-		modelclock_t * newreadClock=(modelclock_t *) malloc(sizeof(modelclock_t)*newCapacity);
+		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));
-		free(record->readClock);
-		free(record->thread);
+		snapshot_free(record->readClock);
+		snapshot_free(record->thread);
 		record->readClock=newreadClock;
 		record->thread=newthread;
 		record->capacity=newCapacity;