small changes

diff --git a/cyclegraph.cc b/cyclegraph.cc
index 6c7e945e98ee8e58ab0a73911f24b8484a935389..1d9533f4ba9b6f2fa61ae0018bb36dc22de5abcc 100644 (file)
--- a/cyclegraph.cc
+++ b/cyclegraph.cc
@@ -70,8 +70,7 @@ void CycleGraph::addNodeEdge(CycleNode *fromnode, CycleNode *tonode, bool forcee
         * If the fromnode has a rmwnode, we should
         * follow its RMW chain to add an edge at the end.
         */
-       while (fromnode->getRMW()) {
-               CycleNode *nextnode = fromnode->getRMW();
+       while (CycleNode * nextnode = fromnode->getRMW()) {
                if (nextnode == tonode)
                        break;
                fromnode = nextnode;

diff --git a/datarace.cc b/datarace.cc
index 06de537546d90ca63f73d86e25fa747e5e5288eb..9c403668e90d7c0fbe6ff76cda3cc3f1a2c37d81 100644 (file)
--- a/datarace.cc
+++ b/datarace.cc
@@ -55,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

diff --git a/execution.cc b/execution.cc
index dcaada34730e37de90cf1529dc9b141ca71ef0c4..8f459d172bd9a1cd8caebd3e5908be856bd889ec 100644 (file)
--- a/execution.cc
+++ b/execution.cc
@@ -250,21 +250,7 @@ void ModelExecution::restore_last_seq_num()
 bool ModelExecution::should_wake_up(const ModelAction *curr, const Thread *thread) const
 {
        const ModelAction *asleep = thread->get_pending();
-       /* Don't allow partial RMW to wake anyone up */
-       if (curr->is_rmwr())
-               return false;
-       /* Synchronizing actions may have been backtracked */
-       if (asleep->could_synchronize_with(curr))
-               return true;
-       /* All acquire/release fences and fence-acquire/store-release */
-       if (asleep->is_fence() && asleep->is_acquire() && curr->is_release())
-               return true;
-       /* Fence-release + store can awake load-acquire on the same location */
-       if (asleep->is_read() && asleep->is_acquire() && curr->same_var(asleep) && curr->is_write()) {
-               ModelAction *fence_release = get_last_fence_release(curr->get_tid());
-               if (fence_release && *(get_last_action(thread->get_id())) < *fence_release)
-                       return true;
-       }
+
        /* The sleep is literally sleeping */
        if (asleep->is_sleep()) {
                if (fuzzer->shouldWake(asleep))
@@ -278,8 +264,8 @@ void ModelExecution::wake_up_sleeping_actions(ModelAction *curr)
 {
        for (unsigned int i = 0;i < get_num_threads();i++) {
                thread_id_t tid = int_to_id(i);
-               Thread *thr = get_thread(tid);
                if (scheduler->is_sleep_set(tid)) {
+                       Thread *thr = get_thread(tid);
                        if (should_wake_up(curr, thr)) {
                                /* Remove this thread from sleep set */
                                scheduler->remove_sleep(thr);
@@ -420,10 +406,10 @@ bool ModelExecution::process_read(ModelAction *curr, SnapVector<ModelAction *> *
                                mo_graph->addEdge((*priorset)[i], rf);
                        }
                        read_from(curr, rf);
-                       get_thread(curr)->set_return_value(curr->get_return_value());
+                       get_thread(curr)->set_return_value(rf->get_write_value());
                        delete priorset;
                        //Update acquire fence clock vector
-                       ClockVector * hbcv = get_hb_from_write(curr->get_reads_from());
+                       ClockVector * hbcv = get_hb_from_write(rf);
                        if (hbcv != NULL)
                                get_thread(curr)->get_acq_fence_cv()->merge(hbcv);
                        return canprune && (curr->get_type() == ATOMIC_READ);
@@ -487,10 +473,10 @@ bool ModelExecution::process_mutex(ModelAction *curr)
        case ATOMIC_WAIT: {
                //TODO: DOESN'T REALLY IMPLEMENT SPURIOUS WAKEUPS CORRECTLY
                if (fuzzer->shouldWait(curr)) {
+                       Thread *curr_thrd = get_thread(curr);
                        /* wake up the other threads */
                        for (unsigned int i = 0;i < get_num_threads();i++) {
                                Thread *t = get_thread(int_to_id(i));
-                               Thread *curr_thrd = get_thread(curr);
                                if (t->waiting_on() == curr_thrd && t->get_pending()->is_lock())
                                        scheduler->wake(t);
                        }
@@ -509,7 +495,7 @@ bool ModelExecution::process_mutex(ModelAction *curr)
                        }
 
                        waiters->push_back(curr);
-                       scheduler->sleep(get_thread(curr));
+                       scheduler->sleep(curr_thrd);
                }
 
                break;
@@ -527,9 +513,9 @@ bool ModelExecution::process_mutex(ModelAction *curr)
 
                // TODO: lock count for recursive mutexes
                /* wake up the other threads */
+               Thread *curr_thrd = get_thread(curr);
                for (unsigned int i = 0;i < get_num_threads();i++) {
                        Thread *t = get_thread(int_to_id(i));
-                       Thread *curr_thrd = get_thread(curr);
                        if (t->waiting_on() == curr_thrd && t->get_pending()->is_lock())
                                scheduler->wake(t);
                }
@@ -770,7 +756,8 @@ bool ModelExecution::synchronize(const ModelAction *first, ModelAction *second)
  * @return a bool that indicates whether the action is enabled.
  */
 bool ModelExecution::check_action_enabled(ModelAction *curr) {
-       if (curr->is_lock()) {
+       switch (curr->get_type()) {
+       case ATOMIC_LOCK: {
                cdsc::mutex *lock = curr->get_mutex();
                struct cdsc::mutex_state *state = lock->get_state();
                if (state->locked) {
@@ -782,14 +769,23 @@ bool ModelExecution::check_action_enabled(ModelAction *curr) {
 
                        return false;
                }
-       } else if (curr->is_thread_join()) {
+               break;
+       }
+       case THREAD_JOIN:
+       case PTHREAD_JOIN: {
                Thread *blocking = curr->get_thread_operand();
                if (!blocking->is_complete()) {
                        return false;
                }
-       } else if (curr->is_sleep()) {
+               break;
+       }
+       case THREAD_SLEEP: {
                if (!fuzzer->shouldSleep(curr))
                        return false;
+               break;
+       }
+       default:
+               return true;
        }
 
        return true;

diff --git a/model.cc b/model.cc
index 4cf5cc57fea4bb94c5998460c701a8b618264c3d..8f974762043065de618aea980d89ac2321ec9dcd 100644 (file)
--- a/model.cc
+++ b/model.cc
@@ -342,7 +342,6 @@ void ModelChecker::startRunExecution(Thread *old) {
                        execution->collectActions();
                }
 
-               thread_chosen = false;
                curr_thread_num = 1;
                Thread *thr = getNextThread(old);
                if (thr != nullptr) {
@@ -386,20 +385,18 @@ Thread* ModelChecker::getNextThread(Thread *old)
                        }
 
                        /* Allow pending relaxed/release stores or thread actions to perform first */
-                       else if (!thread_chosen) {
+                       else if (!chosen_thread) {
                                if (act->is_write()) {
                                        std::memory_order order = act->get_mo();
                                        if (order == std::memory_order_relaxed || \
                                                        order == std::memory_order_release) {
                                                chosen_thread = thr;
-                                               thread_chosen = true;
                                        }
                                } else if (act->get_type() == THREAD_CREATE || \
                                                                         act->get_type() == PTHREAD_CREATE || \
                                                                         act->get_type() == THREAD_START || \
                                                                         act->get_type() == THREAD_FINISH) {
                                        chosen_thread = thr;
-                                       thread_chosen = true;
                                }
                        }
                }
@@ -487,7 +484,7 @@ bool ModelChecker::handleChosenThread(Thread *old)
        if (!chosen_thread) {
                chosen_thread = get_next_thread();
        }
-       if (!chosen_thread || chosen_thread->is_model_thread()) {
+       if (!chosen_thread) {
                finishRunExecution(old);
                return false;
        }

diff --git a/model.h b/model.h
index 03dafd11b1a0aa5493dcf8f1c62f549e788e7a74..fd65c0503b0ecd32ff16536a601a12c5fb9fab68 100644 (file)
--- a/model.h
+++ b/model.h
@@ -73,7 +73,6 @@ private:
 
        unsigned int curr_thread_num;
        Thread * chosen_thread;
-       bool thread_chosen;
        bool break_execution;
 
        void startRunExecution(Thread *old);

diff --git a/threads.cc b/threads.cc
index f83433bc1a0da8696fd3f0d8497f76fcc1943c81..e22ffa3221f83ae1f95abb5b7b6c63da04c72183 100644 (file)
--- a/threads.cc
+++ b/threads.cc
@@ -508,13 +508,15 @@ Thread * Thread::waiting_on() const
        if (!pending)
                return NULL;
 
-       if (pending->get_type() == THREAD_JOIN)
-               return pending->get_thread_operand();
-       else if (pending->get_type() == PTHREAD_JOIN)
-               return pending->get_thread_operand();
-       else if (pending->is_lock())
-               return (Thread *)pending->get_mutex()->get_state()->locked;
-       return NULL;
+       switch (pending->get_type()) {
+               case THREAD_JOIN:
+               case PTHREAD_JOIN:
+                       return pending->get_thread_operand();
+               case ATOMIC_LOCK:
+                       return (Thread *)pending->get_mutex()->get_state()->locked;
+               default:
+                       return NULL;
+       }
 }
 
 /**