Remove unused functions

[c11tester.git] / execution.cc

diff --git a/execution.cc b/execution.cc
index 53b6bccf790df471600a8f555f1ed17249a72443..dcaada34730e37de90cf1529dc9b141ca71ef0c4 100644 (file)
--- a/execution.cc
+++ b/execution.cc
@@ -277,8 +277,9 @@ bool ModelExecution::should_wake_up(const ModelAction *curr, const Thread *threa
 void ModelExecution::wake_up_sleeping_actions(ModelAction *curr)
 {
        for (unsigned int i = 0;i < get_num_threads();i++) {
-               Thread *thr = get_thread(int_to_id(i));
-               if (scheduler->is_sleep_set(thr)) {
+               thread_id_t tid = int_to_id(i);
+               Thread *thr = get_thread(tid);
+               if (scheduler->is_sleep_set(tid)) {
                        if (should_wake_up(curr, thr)) {
                                /* Remove this thread from sleep set */
                                scheduler->remove_sleep(thr);
@@ -808,7 +809,6 @@ bool ModelExecution::check_action_enabled(ModelAction *curr) {
 ModelAction * ModelExecution::check_current_action(ModelAction *curr)
 {
        ASSERT(curr);
-       bool second_part_of_rmw = curr->is_rmwc() || curr->is_rmw();
        bool newly_explored = initialize_curr_action(&curr);
 
        DBG();
@@ -816,20 +816,17 @@ ModelAction * ModelExecution::check_current_action(ModelAction *curr)
        wake_up_sleeping_actions(curr);
 
        SnapVector<ModelAction *> * rf_set = NULL;
+       bool canprune = false;
        /* Build may_read_from set for newly-created actions */
-       if (newly_explored && curr->is_read())
+       if (curr->is_read() && newly_explored) {
                rf_set = build_may_read_from(curr);
-
-       bool canprune = false;
-
-       if (curr->is_read() && !second_part_of_rmw) {
                canprune = process_read(curr, rf_set);
                delete rf_set;
        } else
                ASSERT(rf_set == NULL);
 
-       /* Add the action to lists */
-       if (!second_part_of_rmw) {
+       /* Add the action to lists if not the second part of a rmw */
+       if (newly_explored) {
 #ifdef COLLECT_STAT
                record_atomic_stats(curr);
 #endif
@@ -884,7 +881,7 @@ ModelAction * ModelExecution::process_rmw(ModelAction *act) {
  */
 
 bool ModelExecution::r_modification_order(ModelAction *curr, const ModelAction *rf,
-                                                                                                                                                                       SnapVector<ModelAction *> * priorset, bool * canprune, bool check_only)
+                                                                                                                                                                       SnapVector<ModelAction *> * priorset, bool * canprune)
 {
        SnapVector<action_list_t> *thrd_lists = obj_thrd_map.get(curr->get_location());
        ASSERT(curr->is_read());
@@ -947,8 +944,7 @@ bool ModelExecution::r_modification_order(ModelAction *curr, const ModelAction *
                                                *act < *last_sc_fence_thread_local) {
                                        if (mo_graph->checkReachable(rf, act))
                                                return false;
-                                       if (!check_only)
-                                               priorset->push_back(act);
+                                       priorset->push_back(act);
                                        break;
                                }
                                /* C++, Section 29.3 statement 4 */
@@ -956,8 +952,7 @@ bool ModelExecution::r_modification_order(ModelAction *curr, const ModelAction *
                                                                 *act < *last_sc_fence_local) {
                                        if (mo_graph->checkReachable(rf, act))
                                                return false;
-                                       if (!check_only)
-                                               priorset->push_back(act);
+                                       priorset->push_back(act);
                                        break;
                                }
                                /* C++, Section 29.3 statement 6 */
@@ -965,8 +960,7 @@ bool ModelExecution::r_modification_order(ModelAction *curr, const ModelAction *
                                                                 *act < *last_sc_fence_thread_before) {
                                        if (mo_graph->checkReachable(rf, act))
                                                return false;
-                                       if (!check_only)
-                                               priorset->push_back(act);
+                                       priorset->push_back(act);
                                        break;
                                }
                        }
@@ -985,20 +979,17 @@ bool ModelExecution::r_modification_order(ModelAction *curr, const ModelAction *
                                if (act->is_write()) {
                                        if (mo_graph->checkReachable(rf, act))
                                                return false;
-                                       if (!check_only)
-                                               priorset->push_back(act);
+                                       priorset->push_back(act);
                                } else {
                                        ModelAction *prevrf = act->get_reads_from();
                                        if (!prevrf->equals(rf)) {
                                                if (mo_graph->checkReachable(rf, prevrf))
                                                        return false;
-                                               if (!check_only)
-                                                       priorset->push_back(prevrf);
+                                               priorset->push_back(prevrf);
                                        } else {
                                                if (act->get_tid() == curr->get_tid()) {
                                                        //Can prune curr from obj list
-                                                       if (!check_only)
-                                                               *canprune = true;
+                                                       *canprune = true;
                                                }
                                        }
                                }
@@ -1120,43 +1111,6 @@ void ModelExecution::w_modification_order(ModelAction *curr)
 
 }
 
-/**
- * Arbitrary reads from the future are not allowed. Section 29.3 part 9 places
- * some constraints. This method checks one the following constraint (others
- * require compiler support):
- *
- *   If X --hb-> Y --mo-> Z, then X should not read from Z.
- *   If X --hb-> Y, A --rf-> Y, and A --mo-> Z, then X should not read from Z.
- */
-bool ModelExecution::mo_may_allow(const ModelAction *writer, const ModelAction *reader)
-{
-       SnapVector<action_list_t> *thrd_lists = obj_thrd_map.get(reader->get_location());
-       unsigned int i;
-       /* Iterate over all threads */
-       for (i = 0;i < thrd_lists->size();i++) {
-               const ModelAction *write_after_read = NULL;
-
-               /* Iterate over actions in thread, starting from most recent */
-               action_list_t *list = &(*thrd_lists)[i];
-               sllnode<ModelAction *>* rit;
-               for (rit = list->end();rit != NULL;rit=rit->getPrev()) {
-                       ModelAction *act = rit->getVal();
-
-                       /* Don't disallow due to act == reader */
-                       if (!reader->happens_before(act) || reader == act)
-                               break;
-                       else if (act->is_write())
-                               write_after_read = act;
-                       else if (act->is_read() && act->get_reads_from() != NULL)
-                               write_after_read = act->get_reads_from();
-               }
-
-               if (write_after_read && write_after_read != writer && mo_graph->checkReachable(write_after_read, writer))
-                       return false;
-       }
-       return true;
-}
-
 /**
  * Computes the clock vector that happens before propagates from this write.
  *
@@ -1819,7 +1773,7 @@ ClockVector * ModelExecution::computeMinimalCV() {
        //Thread 0 isn't a real thread, so skip it..
        for(unsigned int i = 1;i < thread_map.size();i++) {
                Thread * t = thread_map[i];
-               if (t->get_state() == THREAD_COMPLETED)
+               if (t->is_complete())
                        continue;
                thread_id_t tid = int_to_id(i);
                ClockVector * cv = get_cv(tid);