merge massive speedup with release sequence support...

[model-checker.git] / action.cc

diff --git a/action.cc b/action.cc
index c6504cd388d0f44f6ec72c038d36996b79fad882..c1adc2e7bc65cd94d26a4b7cf93ac3482c2b2d1a 100644 (file)
--- a/action.cc
+++ b/action.cc
@@ -8,19 +8,34 @@
 #include "clockvector.h"
 #include "common.h"
 #include "threads.h"
+#include "nodestack.h"
 
 #define ACTION_INITIAL_CLOCK 0
 
-ModelAction::ModelAction(action_type_t type, memory_order order, void *loc, uint64_t value) :
+/**
+ * @brief Construct a new ModelAction
+ *
+ * @param type The type of action
+ * @param order The memory order of this action. A "don't care" for non-ATOMIC
+ * actions (e.g., THREAD_* or MODEL_* actions).
+ * @param loc The location that this action acts upon
+ * @param value (optional) A value associated with the action (e.g., the value
+ * read or written). Defaults to a given macro constant, for debugging purposes.
+ * @param thread (optional) The Thread in which this action occurred. If NULL
+ * (default), then a Thread is assigned according to the scheduler.
+ */
+ModelAction::ModelAction(action_type_t type, memory_order order, void *loc,
+               uint64_t value, Thread *thread) :
        type(type),
        order(order),
        location(loc),
        value(value),
        reads_from(NULL),
+       node(NULL),
        seq_number(ACTION_INITIAL_CLOCK),
        cv(NULL)
 {
-       Thread *t = thread_current();
+       Thread *t = thread ? thread : thread_current();
        this->tid = t->get_id();
 }
 
@@ -50,6 +65,11 @@ void ModelAction::set_seq_number(modelclock_t num)
        seq_number = num;
 }
 
+bool ModelAction::is_relseq_fixup() const
+{
+       return type == MODEL_FIXUP_RELSEQ;
+}
+
 bool ModelAction::is_mutex_op() const
 {
        return type == ATOMIC_LOCK || type == ATOMIC_TRYLOCK || type == ATOMIC_UNLOCK;
@@ -184,7 +204,7 @@ void ModelAction::process_rmw(ModelAction * act) {
  *  @param act is the action to consider exploring a reordering.
  *  @return tells whether we have to explore a reordering.
  */
-bool ModelAction::is_synchronizing(const ModelAction *act) const
+bool ModelAction::could_synchronize_with(const ModelAction *act) const
 {
        //Same thread can't be reordered
        if (same_thread(act))
@@ -196,14 +216,12 @@ bool ModelAction::is_synchronizing(const ModelAction *act) const
 
        // Explore interleavings of seqcst writes to guarantee total order
        // of seq_cst operations that don't commute
-       if (is_write() && is_seqcst() && act->is_write() && act->is_seqcst())
+       if ((is_write() || act->is_write()) && is_seqcst() && act->is_seqcst())
                return true;
 
        // Explore synchronizing read/write pairs
        if (is_read() && is_acquire() && act->is_write() && act->is_release())
                return true;
-       if (is_write() && is_release() && act->is_read() && act->is_acquire())
-               return true;
 
        // Otherwise handle by reads_from relation
        return false;
@@ -307,6 +325,9 @@ void ModelAction::print() const
 {
        const char *type_str, *mo_str;
        switch (this->type) {
+       case MODEL_FIXUP_RELSEQ:
+               type_str = "relseq fixup";
+               break;
        case THREAD_CREATE:
                type_str = "thread create";
                break;