/* Initialize default scheduler */
scheduler(new Scheduler()),
num_executions(0),
+ num_feasible_executions(0),
params(params),
diverge(NULL),
action_trace(new action_list_t()),
DBG();
num_executions++;
+ if (isfinalfeasible())
+ num_feasible_executions++;
if (isfinalfeasible() || DBG_ENABLED())
print_summary();
curr = tmp;
compute_promises(curr);
} else {
- ModelAction *tmp = node_stack->explore_action(curr);
+ ModelAction *tmp = node_stack->explore_action(curr, NULL);
if (tmp) {
/* Discard duplicate ModelAction; use action from NodeStack */
/* First restore type and order in case of RMW operation */
break;
}
case WORK_CHECK_RELEASE_SEQ:
- resolve_release_sequences(work.location);
+ resolve_release_sequences(work.location, &work_queue);
break;
case WORK_CHECK_MO_EDGES:
/** @todo Perform follow-up mo_graph checks */
}
/**
- * Updates the mo_graph with the constraints imposed from the current read.
+ * Updates the mo_graph with the constraints imposed from the current
+ * read.
+ *
+ * Basic idea is the following: Go through each other thread and find
+ * the lastest action that happened before our read. Two cases:
+ *
+ * (1) The action is a write => that write must either occur before
+ * the write we read from or be the write we read from.
+ *
+ * (2) The action is a read => the write that that action read from
+ * must occur before the write we read from or be the same write.
+ *
* @param curr The current action. Must be a read.
* @param rf The action that curr reads from. Must be a write.
* @return True if modification order edges were added; false otherwise
return added;
}
-/** Updates the mo_graph with the constraints imposed from the current read. */
+/** This method fixes up the modification order when we resolve a
+ * promises. The basic problem is that actions that occur after the
+ * read curr could not property add items to the modification order
+ * for our read.
+ *
+ * So for each thread, we find the earliest item that happens after
+ * the read curr. This is the item we have to fix up with additional
+ * constraints. If that action is write, we add a MO edge between
+ * the Action rf and that action. If the action is a read, we add a
+ * MO edge between the Action rf, and whatever the read accessed.
+ *
+ * @param curr is the read ModelAction that we are fixing up MO edges for.
+ * @param rf is the write ModelAction that curr reads from.
+ *
+ */
+
void ModelChecker::post_r_modification_order(ModelAction *curr, const ModelAction *rf)
{
std::vector<action_list_t> *thrd_lists = obj_thrd_map->get_safe_ptr(curr->get_location());
/**
* Updates the mo_graph with the constraints imposed from the current write.
+ *
+ * Basic idea is the following: Go through each other thread and find
+ * the lastest action that happened before our write. Two cases:
+ *
+ * (1) The action is a write => that write must occur before
+ * the current write
+ *
+ * (2) The action is a read => the write that that action read from
+ * must occur before the current write.
+ *
+ * This method also handles two other issues:
+ *
+ * (I) Sequential Consistency: Making sure that if the current write is
+ * seq_cst, that it occurs after the previous seq_cst write.
+ *
+ * (II) Sending the write back to non-synchronizing reads.
+ *
* @param curr The current action. Must be a write.
* @return True if modification order edges were added; false otherwise
*/
*
* @param location The location/object that should be checked for release
* sequence resolutions
- * @return True if any updates occurred (new synchronization, new mo_graph edges)
+ * @param work_queue The work queue to which to add work items as they are
+ * generated
+ * @return True if any updates occurred (new synchronization, new mo_graph
+ * edges)
*/
-bool ModelChecker::resolve_release_sequences(void *location)
+bool ModelChecker::resolve_release_sequences(void *location, work_queue_t *work_queue)
{
std::list<ModelAction *> *list;
list = lazy_sync_with_release->getptr(location);
}
if (updated) {
+ /* Re-check act for mo_graph edges */
+ work_queue->push_back(MOEdgeWorkEntry(act));
+
/* propagate synchronization to later actions */
action_list_t::reverse_iterator it = action_trace->rbegin();
while ((*it) != act) {
ModelAction *propagate = *it;
- if (act->happens_before(propagate))
- /** @todo new mo_graph edges along with
- * this synchronization? */
+ if (act->happens_before(propagate)) {
propagate->synchronize_with(act);
+ /* Re-check 'propagate' for mo_graph edges */
+ work_queue->push_back(MOEdgeWorkEntry(propagate));
+ }
}
}
if (complete) {
if (read->is_rmw()) {
mo_graph->addRMWEdge(write, read);
}
+ //First fix up the modification order for actions that happened
+ //before the read
r_modification_order(read, write);
+ //Next fix up the modification order for actions that happened
+ //after the read.
post_r_modification_order(read, write);
promises->erase(promises->begin() + promise_index);
resolved = true;
{
printf("\n");
printf("Number of executions: %d\n", num_executions);
+ printf("Number of feasible executions: %d\n", num_feasible_executions);
printf("Total nodes created: %d\n", node_stack->get_total_nodes());
+#if SUPPORT_MOD_ORDER_DUMP
scheduler->print();
+ char buffername[100];
+ sprintf(buffername, "exec%u",num_executions);
+ mo_graph->dumpGraphToFile(buffername);
+#endif
if (!isfinalfeasible())
printf("INFEASIBLE EXECUTION!\n");