}
bool updated = false;
+
if (curr->is_read()) {
updated = process_read(curr, get_thread(curr), second_part_of_rmw);
}
if (curr->is_write()) {
bool updated_mod_order = w_modification_order(curr);
bool updated_promises = resolve_promises(curr);
- updated = updated_mod_order|updated_promises;
+ updated = updated || updated_mod_order || updated_promises;
if (promises->size()==0) {
for (unsigned int i = 0; i<futurevalues->size(); i++) {
}
/**
- * 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
*/
* false otherwise
*/
bool ModelChecker::release_seq_head(const ModelAction *rf,
- std::vector<const ModelAction *> *release_heads) const
+ std::vector< const ModelAction *, MyAlloc<const ModelAction *> > *release_heads) const
{
if (!rf) {
/* read from future: need to settle this later */
* @see ModelChecker::release_seq_head
*/
void ModelChecker::get_release_seq_heads(ModelAction *act,
- std::vector<const ModelAction *> *release_heads)
+ std::vector< const ModelAction *, MyAlloc<const ModelAction *> > *release_heads)
{
const ModelAction *rf = act->get_reads_from();
bool complete;
while (it != list->end()) {
ModelAction *act = *it;
const ModelAction *rf = act->get_reads_from();
- std::vector<const ModelAction *> release_heads;
+ std::vector< const ModelAction *, MyAlloc<const ModelAction *> > release_heads;
bool complete;
complete = release_seq_head(rf, &release_heads);
for (unsigned int i = 0; i < release_heads.size(); i++) {
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("Number of executions: %d\n", num_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");
projects / model-checker.git / blobdiff