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 *>();
write_locations->add(loc);
history->update_loc_wr_func_nodes_map(loc, this);
}
-
}
if (act->is_read()) {
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;
{
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
}