un-'const' some Promises

[c11tester.git] / model.cc

diff --git a/model.cc b/model.cc
index 0c201fd381aa239eeaa060d6e46f22aae9023579..44fba7eabc84839bc71bc64e7b69f18bb123b676 100644 (file)
--- a/model.cc
+++ b/model.cc
@@ -259,14 +259,10 @@ Thread * ModelChecker::get_next_thread(ModelAction *curr)
                        /* The next node will try to satisfy a different set of promises. */
                        tid = next->get_tid();
                        node_stack->pop_restofstack(2);
-               } else if (nextnode->increment_read_from_past()) {
+               } else if (nextnode->increment_read_from()) {
                        /* The next node will read from a different value. */
                        tid = next->get_tid();
                        node_stack->pop_restofstack(2);
-               } else if (nextnode->increment_future_value()) {
-                       /* The next node will try to read from a different future value. */
-                       tid = next->get_tid();
-                       node_stack->pop_restofstack(2);
                } else if (nextnode->increment_relseq_break()) {
                        /* The next node will try to resolve a release sequence differently */
                        tid = next->get_tid();
@@ -848,19 +844,21 @@ ModelAction * ModelChecker::get_next_backtrack()
  */
 bool ModelChecker::process_read(ModelAction *curr)
 {
+       Node *node = curr->get_node();
        uint64_t value = VALUE_NONE;
        bool updated = false;
        while (true) {
-               const ModelAction *rf = curr->get_node()->get_read_from_past();
-               if (rf != NULL) {
-                       mo_graph->startChanges();
+               switch (node->get_read_from_status()) {
+               case READ_FROM_PAST: {
+                       const ModelAction *rf = node->get_read_from_past();
+                       ASSERT(rf);
 
+                       mo_graph->startChanges();
                        value = rf->get_value();
-
                        check_recency(curr, rf);
                        bool r_status = r_modification_order(curr, rf);
 
-                       if (is_infeasible() && (curr->get_node()->increment_read_from_past() || curr->get_node()->increment_future_value())) {
+                       if (is_infeasible() && node->increment_read_from()) {
                                mo_graph->rollbackChanges();
                                priv->too_many_reads = false;
                                continue;
@@ -871,9 +869,20 @@ bool ModelChecker::process_read(ModelAction *curr)
                        mo_check_promises(curr, true);
 
                        updated |= r_status;
-               } else {
+                       break;
+               }
+               case READ_FROM_PROMISE: {
+                       Promise *promise = curr->get_node()->get_read_from_promise();
+                       value = promise->get_value();
+                       curr->set_read_from_promise(promise);
+                       mo_graph->startChanges();
+                       updated = r_modification_order(curr, promise);
+                       mo_graph->commitChanges();
+                       break;
+               }
+               case READ_FROM_FUTURE: {
                        /* Read from future value */
-                       struct future_value fv = curr->get_node()->get_future_value();
+                       struct future_value fv = node->get_future_value();
                        Promise *promise = new Promise(curr, fv);
                        value = fv.value;
                        curr->set_read_from_promise(promise);
@@ -881,6 +890,10 @@ bool ModelChecker::process_read(ModelAction *curr)
                        mo_graph->startChanges();
                        updated = r_modification_order(curr, promise);
                        mo_graph->commitChanges();
+                       break;
+               }
+               default:
+                       ASSERT(false);
                }
                get_thread(curr)->set_return_value(value);
                return updated;
@@ -1501,8 +1514,7 @@ void ModelChecker::check_curr_backtracking(ModelAction *curr)
 
        if ((parnode && !parnode->backtrack_empty()) ||
                         !currnode->misc_empty() ||
-                        !currnode->read_from_past_empty() ||
-                        !currnode->future_value_empty() ||
+                        !currnode->read_from_empty() ||
                         !currnode->promise_empty() ||
                         !currnode->relseq_break_empty()) {
                set_latest_backtrack(curr);
@@ -2488,7 +2500,7 @@ void ModelChecker::compute_promises(ModelAction *curr)
                                !act->could_synchronize_with(curr) &&
                                promise->is_compatible(curr) &&
                                promise->get_value() == curr->get_value()) {
-                       curr->get_node()->set_promise(i, act->is_rmw());
+                       curr->get_node()->set_promise(i);
                }
        }
 }
@@ -2649,16 +2661,14 @@ void ModelChecker::build_may_read_from(ModelAction *curr)
                        /* Only add feasible future-values */
                        mo_graph->startChanges();
                        r_modification_order(curr, promise);
-                       if (!is_infeasible()) {
-                               const struct future_value fv = promise->get_fv();
-                               curr->get_node()->add_future_value(fv);
-                       }
+                       if (!is_infeasible())
+                               curr->get_node()->add_read_from_promise(promise_read);
                        mo_graph->rollbackChanges();
                }
        }
 
        /* We may find no valid may-read-from only if the execution is doomed */
-       if (!curr->get_node()->get_read_from_past_size() && curr->get_node()->future_value_empty()) {
+       if (!curr->get_node()->read_from_size()) {
                priv->no_valid_reads = true;
                set_assert();
        }