execution: remove redundant condition, reword doc for promises_may_allow

[model-checker.git] / execution.cc

diff --git a/execution.cc b/execution.cc
index 4e154275eac6b42cb4ea805ab9e86bf6a63cd2b5..53aa5212f0b017622d0c284f1cbc765e0620fddd 100644 (file)
--- a/execution.cc
+++ b/execution.cc
@@ -755,12 +755,13 @@ bool ModelExecution::process_mutex(ModelAction *curr)
 /**
  * @brief Check if the current pending promises allow a future value to be sent
  *
- * If one of the following is true:
- *  (a) there are no pending promises
- *  (b) the reader and writer do not cross any promises
- * Then, it is safe to pass a future value back now.
+ * It is unsafe to pass a future value back if there exists a pending promise Pr
+ * such that:
  *
- * Otherwise, we must save the pending future value until (a) or (b) is true
+ *    reader --exec-> Pr --exec-> writer
+ *
+ * If such Pr exists, we must save the pending future value until Pr is
+ * resolved.
  *
  * @param writer The operation which sends the future value. Must be a write.
  * @param reader The operation which will observe the value. Must be a read.
@@ -769,8 +770,6 @@ bool ModelExecution::process_mutex(ModelAction *curr)
 bool ModelExecution::promises_may_allow(const ModelAction *writer,
                const ModelAction *reader) const
 {
-       if (promises.empty())
-               return true;
        for (int i = promises.size() - 1; i >= 0; i--) {
                ModelAction *pr = promises[i]->get_reader(0);
                //reader is after promise...doesn't cross any promise
@@ -817,9 +816,10 @@ void ModelExecution::add_future_value(const ModelAction *writer, ModelAction *re
 /**
  * Process a write ModelAction
  * @param curr The ModelAction to process
+ * @param work The work queue, for adding fixup work
  * @return True if the mo_graph was updated or promises were resolved
  */
-bool ModelExecution::process_write(ModelAction *curr)
+bool ModelExecution::process_write(ModelAction *curr, work_queue_t *work)
 {
        /* Readers to which we may send our future value */
        ModelVector<ModelAction *> send_fv;
@@ -832,7 +832,7 @@ bool ModelExecution::process_write(ModelAction *curr)
 
        if (promise) {
                earliest_promise_reader = promise->get_reader(0);
-               updated_promises = resolve_promise(curr, promise);
+               updated_promises = resolve_promise(curr, promise, work);
        } else
                earliest_promise_reader = NULL;
 
@@ -1272,7 +1272,7 @@ ModelAction * ModelExecution::check_current_action(ModelAction *curr)
                        if (act->is_read() && !second_part_of_rmw && process_read(act))
                                update = true;
 
-                       if (act->is_write() && process_write(act))
+                       if (act->is_write() && process_write(act, &work_queue))
                                update = true;
 
                        if (act->is_fence() && process_fence(act))
@@ -1388,7 +1388,7 @@ void ModelExecution::print_infeasibility(const char *prefix) const
        if (promises.size() != 0)
                ptr += sprintf(ptr, "[unresolved promise]");
        if (ptr != buf)
-               model_print("%s: %s\n", prefix ? prefix : "Infeasible", buf);
+               model_print("%s: %s", prefix ? prefix : "Infeasible", buf);
 }
 
 /**
@@ -1819,6 +1819,7 @@ bool ModelExecution::thin_air_constraint_may_allow(const ModelAction *writer, co
  * 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)
 {
@@ -2333,15 +2334,20 @@ Promise * ModelExecution::pop_promise_to_resolve(const ModelAction *curr)
  * Resolve a Promise with a current write.
  * @param write The ModelAction that is fulfilling Promises
  * @param promise The Promise to resolve
+ * @param work The work queue, for adding new fixup work
  * @return True if the Promise was successfully resolved; false otherwise
  */
-bool ModelExecution::resolve_promise(ModelAction *write, Promise *promise)
+bool ModelExecution::resolve_promise(ModelAction *write, Promise *promise,
+               work_queue_t *work)
 {
        ModelVector<ModelAction *> actions_to_check;
 
        for (unsigned int i = 0; i < promise->get_num_readers(); i++) {
                ModelAction *read = promise->get_reader(i);
-               read_from(read, write);
+               if (read_from(read, write)) {
+                       /* Propagate the changed clock vector */
+                       propagate_clockvector(read, work);
+               }
                actions_to_check.push_back(read);
        }
        /* Make sure the promise's value matches the write's value */
@@ -2624,7 +2630,9 @@ static void print_list(const action_list_t *list)
 {
        action_list_t::const_iterator it;
 
-       model_print("---------------------------------------------------------------------\n");
+       model_print("------------------------------------------------------------------------------------\n");
+       model_print("#    t    Action type     MO       Location         Value               Rf  CV\n");
+       model_print("------------------------------------------------------------------------------------\n");
 
        unsigned int hash = 0;
 
@@ -2635,7 +2643,7 @@ static void print_list(const action_list_t *list)
                hash = hash^(hash<<3)^((*it)->hash());
        }
        model_print("HASH %u\n", hash);
-       model_print("---------------------------------------------------------------------\n");
+       model_print("------------------------------------------------------------------------------------\n");
 }
 
 #if SUPPORT_MOD_ORDER_DUMP
@@ -2689,17 +2697,21 @@ void ModelExecution::print_summary() const
        dumpGraph(buffername);
 #endif
 
-       model_print("Execution %d:", get_execution_number());
+       model_print("Execution trace %d:", get_execution_number());
        if (isfeasibleprefix()) {
                if (is_yieldblocked())
                        model_print(" YIELD BLOCKED");
                if (scheduler->all_threads_sleeping())
                        model_print(" SLEEP-SET REDUNDANT");
-               model_print("\n");
+               if (have_bug_reports())
+                       model_print(" DETECTED BUG(S)");
        } else
                print_infeasibility(" INFEASIBLE");
+       model_print("\n");
+
        print_list(&action_trace);
        model_print("\n");
+
        if (!promises.empty()) {
                model_print("Pending promises:\n");
                for (unsigned int i = 0; i < promises.size(); i++) {