Complete the transfer of deletions of some actions

[c11tester.git] / history.cc

diff --git a/history.cc b/history.cc
index a5b437c512992793d6e550a90f2f3f497a5146da..3fe570b28e8c71f1334f195d4be23253a8efbe75 100644 (file)
--- a/history.cc
+++ b/history.cc
@@ -23,6 +23,9 @@ ModelHistory::ModelHistory() :
        loc_rd_func_nodes_map = new HashTable<void *, SnapVector<FuncNode *> *, uintptr_t, 0>();
        loc_wr_func_nodes_map = new HashTable<void *, SnapVector<FuncNode *> *, uintptr_t, 0>();
        loc_waiting_writes_map = new HashTable<void *, SnapVector<ConcretePredicate *> *, uintptr_t, 0>();
+       thrd_func_act_lists = new SnapVector< SnapList<action_list_t *> *>();
+       thrd_func_list = new SnapVector<func_id_list_t>();
+       thrd_last_entered_func = new SnapVector<uint32_t>();
        thrd_waiting_write = new SnapVector<ConcretePredicate *>();
        thrd_wait_obj = new SnapVector<WaitObj *>();
        func_inst_act_maps = new HashTable<uint32_t, SnapVector<inst_act_map_t *> *, int, 0>(128);
@@ -38,14 +41,8 @@ ModelHistory::~ModelHistory()
 void ModelHistory::enter_function(const uint32_t func_id, thread_id_t tid)
 {
        //model_print("thread %d entering func %d\n", tid, func_id);
-       ModelExecution * execution = model->get_execution();
        uint id = id_to_int(tid);
 
-       SnapVector<func_id_list_t> * thrd_func_list = execution->get_thrd_func_list();
-       SnapVector< SnapList<action_list_t *> *> *
-               thrd_func_act_lists = execution->get_thrd_func_act_lists();
-       SnapVector<uint32_t> * thrd_last_entered_func = execution->get_thrd_last_entered_func();
-
        if ( thrd_func_list->size() <= id ) {
                uint oldsize = thrd_func_list->size();
                thrd_func_list->resize( id + 1 );
@@ -82,17 +79,13 @@ void ModelHistory::enter_function(const uint32_t func_id, thread_id_t tid)
        }
 
        /* Monitor the statuses of threads waiting for tid */
-       monitor_waiting_thread(func_id, tid);
+       // monitor_waiting_thread(func_id, tid);
 }
 
 /* @param func_id a non-zero value */
 void ModelHistory::exit_function(const uint32_t func_id, thread_id_t tid)
 {
-       ModelExecution * execution = model->get_execution();
        uint32_t id = id_to_int(tid);
-       SnapVector<func_id_list_t> * thrd_func_list = execution->get_thrd_func_list();
-       SnapVector< SnapList<action_list_t *> *> *
-               thrd_func_act_lists = execution->get_thrd_func_act_lists();
 
        SnapList<action_list_t *> * func_act_lists = (*thrd_func_act_lists)[id];
        uint32_t last_func_id = (*thrd_func_list)[id].back();
@@ -147,18 +140,13 @@ void ModelHistory::resize_func_nodes(uint32_t new_size)
 
 void ModelHistory::process_action(ModelAction *act, thread_id_t tid)
 {
-       ModelExecution * execution = model->get_execution();
-       SnapVector<func_id_list_t> * thrd_func_list = execution->get_thrd_func_list();
-       SnapVector< SnapList<action_list_t *> *> *
-               thrd_func_act_lists = execution->get_thrd_func_act_lists();
-
        uint32_t thread_id = id_to_int(tid);
        /* Return if thread tid has not entered any function that contains atomics */
        if ( thrd_func_list->size() <= thread_id )
                return;
 
        /* Monitor the statuses of threads waiting for tid */
-       monitor_waiting_thread_counter(tid);
+       // monitor_waiting_thread_counter(tid);
 
        /* Every write action should be processed, including
         * nonatomic writes (which have no position) */
@@ -195,6 +183,13 @@ void ModelHistory::process_action(ModelAction *act, thread_id_t tid)
        /* Add to curr_inst_list */
        curr_act_list->push_back(act);
 
+       // Increment ref count for every action and reads_froms
+       act->incr_read_ref_count();
+       if (act->is_read()) {
+               ModelAction * rf = act->get_reads_from();
+               rf->incr_read_ref_count();
+       }
+
        FuncNode * func_node = func_nodes[func_id];
        func_node->add_inst(act);
 
@@ -202,7 +197,7 @@ void ModelHistory::process_action(ModelAction *act, thread_id_t tid)
                func_node->update_inst_act_map(tid, act);
 
                Fuzzer * fuzzer = model->get_execution()->getFuzzer();
-               Predicate * selected_branch = fuzzer->get_selected_child_branch(tid);
+               Predicate * selected_branch = ((NewFuzzer *)fuzzer)->get_selected_child_branch(tid);
                func_node->set_predicate_tree_position(tid, selected_branch);
        }
 
@@ -212,7 +207,7 @@ void ModelHistory::process_action(ModelAction *act, thread_id_t tid)
 
                if (curr_pred) {
                        // Follow child
-                       curr_pred = curr_pred->get_single_child(curr_inst);
+                       curr_pred = curr_pred->follow_write_child(curr_inst);
                }
                func_node->set_predicate_tree_position(tid, curr_pred);
        }
@@ -235,7 +230,6 @@ FuncNode * ModelHistory::get_func_node(uint32_t func_id)
 FuncNode * ModelHistory::get_curr_func_node(thread_id_t tid)
 {
        int thread_id = id_to_int(tid);
-       SnapVector<func_id_list_t> * thrd_func_list =  model->get_execution()->get_thrd_func_list();
        uint32_t func_id = (*thrd_func_list)[thread_id].back();
 
        if (func_id != 0) {
@@ -376,7 +370,7 @@ void ModelHistory::check_waiting_write(ModelAction * write_act)
                        Thread * thread = model->get_thread(tid);
 
                        //model_print("** thread %d is woken up\n", thread->get_id());
-                       model->get_execution()->getFuzzer()->notify_paused_thread(thread);
+                       ((NewFuzzer *)model->get_execution()->getFuzzer())->notify_paused_thread(thread);
                }
 
                index++;
@@ -398,7 +392,7 @@ WaitObj * ModelHistory::getWaitObj(thread_id_t tid)
 }
 
 void ModelHistory::add_waiting_thread(thread_id_t self_id,
-thread_id_t waiting_for_id, FuncNode * target_node, int dist)
+                                                                                                                                                       thread_id_t waiting_for_id, FuncNode * target_node, int dist)
 {
        WaitObj * self_wait_obj = getWaitObj(self_id);
        self_wait_obj->add_waiting_for(waiting_for_id, target_node, dist);
@@ -423,10 +417,11 @@ void ModelHistory::remove_waiting_thread(thread_id_t tid)
        }
 
        self_wait_obj->clear_waiting_for();
+       delete iter;
 }
 
 void ModelHistory::stop_waiting_for_node(thread_id_t self_id,
-thread_id_t waiting_for_id, FuncNode * target_node)
+                                                                                                                                                                thread_id_t waiting_for_id, FuncNode * target_node)
 {
        WaitObj * self_wait_obj = getWaitObj(self_id);
        bool thread_removed = self_wait_obj->remove_waiting_for_node(waiting_for_id, target_node);
@@ -443,7 +438,7 @@ thread_id_t waiting_for_id, FuncNode * target_node)
                        // model_print("\tthread %d waits for nobody, wake up\n", self_id);
                        ModelExecution * execution = model->get_execution();
                        Thread * thread = execution->get_thread(self_id);
-                       execution->getFuzzer()->notify_paused_thread(thread);
+                       ((NewFuzzer *)execution->getFuzzer())->notify_paused_thread(thread);
                }
        }
 }
@@ -516,7 +511,11 @@ void ModelHistory::monitor_waiting_thread(uint32_t func_id, thread_id_t tid)
                                stop_waiting_for_node(waited_by_id, tid, target);
                        }
                }
+
+               delete node_iter;
        }
+
+       delete tid_iter;
 }
 
 void ModelHistory::monitor_waiting_thread_counter(thread_id_t tid)
@@ -541,10 +540,12 @@ void ModelHistory::monitor_waiting_thread_counter(thread_id_t tid)
                                // model_print("\tthread %d waits for nobody, wake up\n", self_id);
                                ModelExecution * execution = model->get_execution();
                                Thread * thread = execution->get_thread(waited_by_id);
-                               execution->getFuzzer()->notify_paused_thread(thread);
+                               ((NewFuzzer *)execution->getFuzzer())->notify_paused_thread(thread);
                        }
                }
        }
+
+       delete tid_iter;
 }
 
 /* Reallocate some snapshotted memories when new executions start */
@@ -578,8 +579,8 @@ void ModelHistory::print_func_node()
        /* function id starts with 1 */
        for (uint32_t i = 1;i < func_nodes.size();i++) {
                FuncNode * func_node = func_nodes[i];
-
                func_node->print_predicate_tree();
+
 /*
                 func_inst_list_mt * entry_insts = func_node->get_entry_insts();
                 model_print("function %s has entry actions\n", func_node->get_func_name());