Add some methods for WaitObj

[c11tester.git] / history.cc

diff --git a/history.cc b/history.cc
index faccdacb46a6931783a08ee5a1ec36f92f9a27f2..93abfbc0091806410df585607958c954c68ab069 100644 (file)
--- a/history.cc
+++ b/history.cc
@@ -5,6 +5,7 @@
 #include "funcinst.h"
 #include "common.h"
 #include "concretepredicate.h"
+#include "waitobj.h"
 
 #include "model.h"
 #include "execution.h"
@@ -19,11 +20,12 @@ ModelHistory::ModelHistory() :
 {
        /* The following are snapshot data structures */
        write_history = new HashTable<void *, value_set_t *, uintptr_t, 4>();
-       loc_func_nodes_map = new HashTable<void *, SnapList<FuncNode *> *, uintptr_t, 0>();
-       loc_wr_func_nodes_map = new HashTable<void *, SnapList<FuncNode *> *, uintptr_t, 0>();
+       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_waiting_write = new SnapVector<ConcretePredicate *>();
-       func_inst_act_maps = new HashTable<uint32_t, SnapVector<inst_act_map_t *> *, int, 0>();
+       thrd_wait_obj = new SnapVector<WaitObj *>();
+       func_inst_act_maps = new HashTable<uint32_t, SnapVector<inst_act_map_t *> *, int, 0>(128);
 }
 
 void ModelHistory::enter_function(const uint32_t func_id, thread_id_t tid)
@@ -155,13 +157,10 @@ void ModelHistory::process_action(ModelAction *act, thread_id_t tid)
                update_write_history(location, value);
 
                /* Update FuncNodes that may read from this location */
-               SnapList<FuncNode *> * func_nodes = loc_func_nodes_map->get(location);
-               if (func_nodes != NULL) {
-                       sllnode<FuncNode *> * it = func_nodes->begin();
-                       for (; it != NULL; it = it->getNext()) {
-                               FuncNode * func_node = it->getVal();
-                               func_node->add_to_val_loc_map(value, location);
-                       }
+               SnapVector<FuncNode *> * func_node_list = getRdFuncNodes(location);
+               for (uint i = 0; i < func_node_list->size(); i++) {
+                       FuncNode * func_node = (*func_node_list)[i];
+                       func_node->add_to_val_loc_map(value, location);
                }
 
                check_waiting_write(act);
@@ -232,26 +231,38 @@ void ModelHistory::update_write_history(void * location, uint64_t write_val)
        write_set->add(write_val);
 }
 
-void ModelHistory::update_loc_func_nodes_map(void * location, FuncNode * node)
+void ModelHistory::update_loc_rd_func_nodes_map(void * location, FuncNode * node)
+{
+       SnapVector<FuncNode *> * func_node_list = getRdFuncNodes(location);
+       func_node_list->push_back(node);
+}
+
+void ModelHistory::update_loc_wr_func_nodes_map(void * location, FuncNode * node)
+{
+       SnapVector<FuncNode *> * func_node_list = getWrFuncNodes(location);
+       func_node_list->push_back(node);
+}
+
+SnapVector<FuncNode *> * ModelHistory::getRdFuncNodes(void * location)
 {
-       SnapList<FuncNode *> * func_node_list = loc_func_nodes_map->get(location);
+       SnapVector<FuncNode *> * func_node_list = loc_rd_func_nodes_map->get(location);
        if (func_node_list == NULL) {
-               func_node_list = new SnapList<FuncNode *>();
-               loc_func_nodes_map->put(location, func_node_list);
+               func_node_list = new SnapVector<FuncNode *>();
+               loc_rd_func_nodes_map->put(location, func_node_list);
        }
 
-       func_node_list->push_back(node);
+       return func_node_list;
 }
 
-void ModelHistory::update_loc_wr_func_nodes_map(void * location, FuncNode * node)
+SnapVector<FuncNode *> * ModelHistory::getWrFuncNodes(void * location)
 {
-       SnapList<FuncNode *> * func_node_list = loc_wr_func_nodes_map->get(location);
+       SnapVector<FuncNode *> * func_node_list = loc_wr_func_nodes_map->get(location);
        if (func_node_list == NULL) {
-               func_node_list = new SnapList<FuncNode *>();
-               loc_func_nodes_map->put(location, func_node_list);
+               func_node_list = new SnapVector<FuncNode *>();
+               loc_wr_func_nodes_map->put(location, func_node_list);
        }
 
-       func_node_list->push_back(node);
+       return func_node_list;
 }
 
 /* When a thread is paused by Fuzzer, keep track of the condition it is waiting for */
@@ -281,6 +292,8 @@ void ModelHistory::remove_waiting_write(thread_id_t tid)
        void * location = concrete->get_location();
        SnapVector<ConcretePredicate *> * concrete_preds = loc_waiting_writes_map->get(location);
 
+       /* Linear search should be fine because presumably not many ConcretePredicates
+        * are at the same memory location */
        for (uint i = 0; i < concrete_preds->size(); i++) {
                ConcretePredicate * current = (*concrete_preds)[i];
                if (concrete == current) {
@@ -351,6 +364,42 @@ void ModelHistory::check_waiting_write(ModelAction * write_act)
        }
 }
 
+WaitObj * ModelHistory::getWaitObj(thread_id_t tid)
+{
+       int thread_id = id_to_int(tid);
+       int old_size = thrd_wait_obj->size();
+       if (old_size <= thread_id) {
+               thrd_wait_obj->resize(thread_id + 1);
+               for (int i = old_size; i < thread_id + 1; i++) {
+                       (*thrd_wait_obj)[i] = new WaitObj( int_to_id(i) );
+               }
+       }
+
+       return (*thrd_wait_obj)[thread_id];
+}
+
+void ModelHistory::add_waiting_thread(thread_id_t self_id,
+               thread_id_t waiting_for_id, int dist)
+{
+       WaitObj * self_wait_obj = getWaitObj(self_id);
+       self_wait_obj->add_waiting_for(waiting_for_id, dist);
+
+       /* Update waited-by relation */
+       WaitObj * other_wait_obj = getWaitObj(waiting_for_id);
+       other_wait_obj->add_waited_by(self_id);
+}
+
+void ModelHistory::remove_waiting_thread(thread_id_t self_id, thread_id_t waiting_for_id)
+{
+       WaitObj * self_wait_obj = getWaitObj(self_id);
+       self_wait_obj->remove_waiting_for(waiting_for_id);
+
+       /* Update waited-by relation */
+       WaitObj * other_wait_obj = getWaitObj(waiting_for_id);
+       other_wait_obj->remove_waited_by(self_id);
+}
+
+
 SnapVector<inst_act_map_t *> * ModelHistory::getThrdInstActMap(uint32_t func_id)
 {
        ASSERT(func_id != 0);
@@ -429,3 +478,19 @@ void ModelHistory::print_func_node()
                }
        }
 }
+
+void ModelHistory::print_waiting_threads()
+{
+       ModelExecution * execution = model->get_execution();
+       for (unsigned int i = 0; i < execution->get_num_threads();i++) {
+               thread_id_t tid = int_to_id(i);
+               WaitObj * wait_obj = getWaitObj(tid);
+               wait_obj->print_waiting_for();
+       }
+
+       for (unsigned int i = 0; i < execution->get_num_threads();i++) {
+               thread_id_t tid = int_to_id(i);
+               WaitObj * wait_obj = getWaitObj(tid);
+               wait_obj->print_waited_by();
+       }
+}