action: rename 'node' members to 'treenode'

[model-checker.git] / model.cc

diff --git a/model.cc b/model.cc
index 0084e74fcf69b989f8c2c91a8bdc747caa546494..53411c64199529dcea4e463d1bb058f2ea6898ab 100644 (file)
--- a/model.cc
+++ b/model.cc
@@ -30,18 +30,26 @@ private:
 
 ModelChecker *model;
 
+void free_action_list(action_list_t *list)
+{
+       action_list_t::iterator it;
+       for (it = list->begin(); it != list->end(); it++)
+               delete (*it);
+       delete list;
+}
+
 ModelChecker::ModelChecker()
 {
        /* First thread created will have id INITIAL_THREAD_ID */
-       this->next_thread_id = INITIAL_THREAD_ID;
+       next_thread_id = INITIAL_THREAD_ID;
        used_sequence_numbers = 0;
        /* Initialize default scheduler */
-       this->scheduler = new Scheduler();
+       scheduler = new Scheduler();
 
        num_executions = 0;
-       this->current_action = NULL;
-       this->exploring = NULL;
-       this->nextThread = THREAD_ID_T_NONE;
+       current_action = NULL;
+       exploring = NULL;
+       nextThread = THREAD_ID_T_NONE;
 
        rootNode = new TreeNode();
        currentNode = rootNode;
@@ -50,8 +58,14 @@ ModelChecker::ModelChecker()
 
 ModelChecker::~ModelChecker()
 {
-       delete action_trace;
-       delete this->scheduler;
+       std::map<int, class Thread *>::iterator it;
+       for (it = thread_map.begin(); it != thread_map.end(); it++)
+               delete (*it).second;
+       thread_map.clear();
+
+       free_action_list(action_trace);
+
+       delete scheduler;
        delete rootNode;
 }
 
@@ -86,8 +100,9 @@ Thread * ModelChecker::schedule_next_thread()
        if (nextThread == THREAD_ID_T_NONE)
                return NULL;
        t = thread_map[id_to_int(nextThread)];
-       if (t == NULL)
-               DEBUG("*** error: thread not in thread_map: id = %d\n", nextThread);
+
+       ASSERT(t != NULL);
+
        return t;
 }
 
@@ -106,7 +121,7 @@ thread_id_t ModelChecker::get_next_replay_thread()
        next = exploring->get_state();
 
        if (next == exploring->get_diverge()) {
-               TreeNode *node = next->get_node();
+               TreeNode *node = next->get_treenode();
 
                /* Reached divergence point; discard our current 'exploring' */
                DEBUG("*** Discard 'Backtrack' object ***\n");
@@ -188,7 +203,10 @@ void ModelChecker::set_backtracking(ModelAction *act)
        if (prev == NULL)
                return;
 
-       node = prev->get_node();
+       node = prev->get_treenode();
+
+       while (t && !node->is_enabled(t))
+               t = t->get_parent();
 
        /* Check if this has been explored already */
        if (node->hasBeenExplored(t->get_id()))
@@ -282,99 +300,3 @@ int ModelChecker::switch_to_master(ModelAction *act)
        old->set_state(THREAD_READY);
        return Thread::swap(old, get_system_context());
 }
-
-ModelAction::ModelAction(action_type_t type, memory_order order, void *loc, int value)
-{
-       Thread *t = thread_current();
-       ModelAction *act = this;
-
-       act->type = type;
-       act->order = order;
-       act->location = loc;
-       act->tid = t->get_id();
-       act->value = value;
-       act->seq_number = model->get_next_seq_num();
-}
-
-bool ModelAction::is_read()
-{
-       return type == ATOMIC_READ;
-}
-
-bool ModelAction::is_write()
-{
-       return type == ATOMIC_WRITE;
-}
-
-bool ModelAction::is_acquire()
-{
-       switch (order) {
-       case memory_order_acquire:
-       case memory_order_acq_rel:
-       case memory_order_seq_cst:
-               return true;
-       default:
-               return false;
-       }
-}
-
-bool ModelAction::is_release()
-{
-       switch (order) {
-       case memory_order_release:
-       case memory_order_acq_rel:
-       case memory_order_seq_cst:
-               return true;
-       default:
-               return false;
-       }
-}
-
-bool ModelAction::same_var(ModelAction *act)
-{
-       return location == act->location;
-}
-
-bool ModelAction::same_thread(ModelAction *act)
-{
-       return tid == act->tid;
-}
-
-bool ModelAction::is_dependent(ModelAction *act)
-{
-       if (!is_read() && !is_write())
-               return false;
-       if (!act->is_read() && !act->is_write())
-               return false;
-       if (same_var(act) && !same_thread(act) &&
-                       (is_write() || act->is_write()))
-               return true;
-       return false;
-}
-
-void ModelAction::print(void)
-{
-       const char *type_str;
-       switch (this->type) {
-       case THREAD_CREATE:
-               type_str = "thread create";
-               break;
-       case THREAD_YIELD:
-               type_str = "thread yield";
-               break;
-       case THREAD_JOIN:
-               type_str = "thread join";
-               break;
-       case ATOMIC_READ:
-               type_str = "atomic read";
-               break;
-       case ATOMIC_WRITE:
-               type_str = "atomic write";
-               break;
-       default:
-               type_str = "unknown type";
-       }
-
-       printf("(%4d) Thread: %d\tAction: %s\tMO: %d\tLoc: %14p\tValue: %d\n",
-                       seq_number, id_to_int(tid), type_str, order, location, value);
-}