FuncNode::FuncNode(ModelHistory * history) :
history(history),
exit_count(0),
+ marker(1),
func_inst_map(),
inst_list(),
entry_insts(),
{
predicate_tree_entry = new Predicate(NULL, true);
predicate_tree_entry->add_predicate_expr(NOPREDICATE, NULL, true);
+ predicate_tree_exit = new Predicate(NULL, false, true);
// Memories that are reclaimed after each execution
action_list_buffer = new SnapList<action_list_t *>();
if (act_list == NULL || act_list->size() == 0)
return;
- HashTable<void *, value_set_t *, uintptr_t, 4> * write_history = history->getWriteHistory();
+ HashTable<void *, value_set_t *, uintptr_t, 0> * write_history = history->getWriteHistory();
/* build inst_list from act_list for later processing */
func_inst_list_t inst_list;
write_locations->add(loc);
history->update_loc_wr_func_nodes_map(loc, this);
}
-
}
if (act->is_read()) {
read_locations->add(loc);
value_set_t * write_values = write_history->get(loc);
add_to_val_loc_map(write_values, loc);
- history->update_loc_func_nodes_map(loc, this);
+ history->update_loc_rd_func_nodes_map(loc, this);
}
}
}
if (act_list == NULL || act_list->size() == 0)
return;
+ incr_marker();
+
/* Map a FuncInst to the its predicate */
HashTable<FuncInst *, Predicate *, uintptr_t, 0> inst_pred_map(128);
/* Only need to store the locations of read actions */
HashTable<void *, ModelAction *, uintptr_t, 0> loc_act_map(128);
- HashTable<FuncInst *, ModelAction *, uintptr_t, 0> inst_act_map(128);
sllnode<ModelAction *> *it = act_list->begin();
Predicate * curr_pred = predicate_tree_entry;
while (it != NULL) {
ModelAction * next_act = it->getVal();
FuncInst * next_inst = get_inst(next_act);
+ next_inst->set_associated_act(next_act, marker);
SnapVector<Predicate *> unset_predicates = SnapVector<Predicate *>();
- bool branch_found = follow_branch(&curr_pred, next_inst, next_act, &inst_act_map, &unset_predicates);
+ bool branch_found = follow_branch(&curr_pred, next_inst, next_act, &unset_predicates);
// A branch with unset predicate expression is detected
if (!branch_found && unset_predicates.size() != 0) {
curr_pred->add_backedge(back_pred);
curr_pred = back_pred;
-
continue;
}
}
loc_act_map.put(next_act->get_location(), next_act);
}
- inst_act_map.put(next_inst, next_act);
inst_pred_map.put(next_inst, curr_pred);
if (!inst_id_map.contains(next_inst))
inst_id_map.put(next_inst, inst_counter++);
it = it->getNext();
+ curr_pred->incr_expl_count();
}
+
+ curr_pred->set_exit(predicate_tree_exit);
}
/* Given curr_pred and next_inst, find the branch following curr_pred that
* contains next_inst and the correct predicate.
* @return true if branch found, false otherwise.
*/
-bool FuncNode::follow_branch(Predicate ** curr_pred, FuncInst * next_inst, ModelAction * next_act,
- HashTable<FuncInst *, ModelAction *, uintptr_t, 0> * inst_act_map,
- SnapVector<Predicate *> * unset_predicates)
+bool FuncNode::follow_branch(Predicate ** curr_pred, FuncInst * next_inst,
+ ModelAction * next_act, SnapVector<Predicate *> * unset_predicates)
{
- /* check if a branch with func_inst and corresponding predicate exists */
+ /* Check if a branch with func_inst and corresponding predicate exists */
bool branch_found = false;
ModelVector<Predicate *> * branches = (*curr_pred)->get_children();
for (uint i = 0; i < branches->size(); i++) {
/* Check against predicate expressions */
bool predicate_correct = true;
PredExprSet * pred_expressions = branch->get_pred_expressions();
+ PredExprSetIter * pred_expr_it = pred_expressions->iterator();
/* Only read and rmw actions my have unset predicate expressions */
if (pred_expressions->getSize() == 0) {
unset_predicates->push_back(branch);
}
- ConcretePredicate * concrete_pred = branch->evaluate(inst_act_map, next_act->get_tid());
- SnapVector<struct concrete_pred_expr> * concrete_exprs = concrete_pred->getExpressions();
- for (uint i = 0; i < concrete_exprs->size(); i++) {
- struct concrete_pred_expr concrete = (*concrete_exprs)[i];
- uint64_t next_read;
+ while (pred_expr_it->hasNext()) {
+ pred_expr * pred_expression = pred_expr_it->next();
+ uint64_t last_read, next_read;
bool equality;
- switch (concrete.token) {
+ switch(pred_expression->token) {
case NOPREDICATE:
predicate_correct = true;
break;
case EQUALITY:
+ FuncInst * to_be_compared;
+ ModelAction * last_act;
+
+ to_be_compared = pred_expression->func_inst;
+ last_act = to_be_compared->get_associated_act(marker);
+
+ last_read = last_act->get_reads_from_value();
next_read = next_act->get_reads_from_value();
- equality = (next_read == concrete.value);
- if (equality != concrete.equality)
+ equality = (last_read == next_read);
+ if (equality != pred_expression->value)
predicate_correct = false;
+
break;
case NULLITY:
next_read = next_act->get_reads_from_value();
equality = ((void*)next_read == NULL);
- if (equality != concrete.equality)
+ if (equality != pred_expression->value)
predicate_correct = false;
break;
default:
break;
}
}
- delete concrete_pred;
if (predicate_correct) {
*curr_pred = branch;
}
}
+/* Compute the distance between this FuncNode and the target node.
+ * Return -1 if the target node is unreachable or the actual distance
+ * is greater than max_step.
+ */
+int FuncNode::compute_distance(FuncNode * target, int max_step)
+{
+ if (target == NULL)
+ return -1;
+ else if (target == this)
+ return 0;
+
+ SnapList<FuncNode *> queue;
+ HashTable<FuncNode *, int, uintptr_t, 0> distances(128);
+
+ queue.push_back(this);
+ distances.put(this, 0);
+
+ while (!queue.empty()) {
+ FuncNode * curr = queue.front();
+ queue.pop_front();
+ int dist = distances.get(curr);
+
+ if (max_step <= dist)
+ return -1;
+
+ ModelList<FuncNode *> * outEdges = curr->get_out_edges();
+ mllnode<FuncNode *> * it;
+ for (it = outEdges->begin(); it != NULL; it = it->getNext()) {
+ FuncNode * out_node = it->getVal();
+
+ /* This node has not been visited before */
+ if ( !distances.contains(out_node) ) {
+ if (out_node == target)
+ return dist + 1;
+
+ queue.push_back(out_node);
+ distances.put(out_node, dist + 1);
+ }
+ }
+ }
+
+ /* Target node is unreachable */
+ return -1;
+}
+
void FuncNode::print_predicate_tree()
{
model_print("digraph function_%s {\n", func_name);
predicate_tree_entry->print_pred_subtree();
+ predicate_tree_exit->print_predicate();
model_print("}\n"); // end of graph
}
projects / c11tester.git / blobdiff