Update readme

[c11tester.git] / fuzzer.cc

diff --git a/fuzzer.cc b/fuzzer.cc
index fff0c1e21be8334426f60a15c40e55f2f6a7142b..7e488ce85fe84dbf6126b81b90aa9c48f8bf2c6f 100644 (file)
--- a/fuzzer.cc
+++ b/fuzzer.cc
@@ -2,6 +2,7 @@
 #include <stdlib.h>
 #include "threads-model.h"
 #include "model.h"
+#include "action.h"
 
 int Fuzzer::selectWrite(ModelAction *read, SnapVector<ModelAction *> * rf_set) {
        int random_index = random() % rf_set->size();
@@ -15,13 +16,70 @@ Thread * Fuzzer::selectThread(int * threadlist, int numthreads) {
        return model->get_thread(curr_tid);
 }
 
-Thread * Fuzzer::selectNotify(action_list_t * waiters) {
+Thread * Fuzzer::selectNotify(simple_action_list_t * waiters) {
        int numwaiters = waiters->size();
        int random_index = random() % numwaiters;
        sllnode<ModelAction*> * it = waiters->begin();
        while(random_index--)
-         it=it->getNext();
+               it=it->getNext();
        Thread *thread = model->get_thread(it->getVal());
        waiters->erase(it);
        return thread;
 }
+
+bool Fuzzer::shouldSleep(const ModelAction *sleep) {
+       return true;
+}
+
+bool Fuzzer::shouldWake(const ModelAction *sleep) {
+       struct timespec currtime;
+       clock_gettime(CLOCK_MONOTONIC, &currtime);
+       uint64_t lcurrtime = currtime.tv_sec * 1000000000 + currtime.tv_nsec;
+
+       return ((sleep->get_time()+sleep->get_value()) < lcurrtime);
+}
+
+/* Decide whether wait should spuriously fail or not */
+bool Fuzzer::waitShouldFail(ModelAction * wait)
+{
+       if ((random() & 1) == 0) {
+               struct timespec currtime;
+        clock_gettime(CLOCK_MONOTONIC, &currtime);
+        uint64_t lcurrtime = currtime.tv_sec * 1000000000 + currtime.tv_nsec;
+
+               // The time after which wait fail spuriously, in nanoseconds
+               uint64_t time = random() % 1000000;
+               wait->set_time(time + lcurrtime);
+               return true;
+       }
+
+       return false;
+}
+
+bool Fuzzer::waitShouldWakeUp(const ModelAction * wait)
+{
+       struct timespec currtime;
+       clock_gettime(CLOCK_MONOTONIC, &currtime);
+       uint64_t lcurrtime = currtime.tv_sec * 1000000000 + currtime.tv_nsec;
+
+       return (wait->get_time() < lcurrtime);
+}
+
+bool Fuzzer::randomizeWaitTime(ModelAction * timed_wait)
+{
+       uint64_t abstime = timed_wait->get_time();
+       struct timespec currtime;
+       clock_gettime(CLOCK_MONOTONIC, &currtime);
+       uint64_t lcurrtime = currtime.tv_sec * 1000000000 + currtime.tv_nsec;
+       if (abstime <= lcurrtime)
+               return false;
+
+       // Shorten wait time
+       if ((random() & 1) == 0) {
+               uint64_t tmp = abstime - lcurrtime;
+               uint64_t time_to_expire = random() % tmp + lcurrtime;
+               timed_wait->set_time(time_to_expire);
+       }
+
+       return true;
+}