obj_thrd_map(new HashTable<void *, std::vector<action_list_t>, uintptr_t, 4 >()),
promises(new std::vector<Promise *>()),
futurevalues(new std::vector<struct PendingFutureValue>()),
- pending_acq_rel_seq(new std::vector<ModelAction *>()),
+ pending_rel_seqs(new std::vector<struct release_seq *>()),
thrd_last_action(new std::vector<ModelAction *>(1)),
node_stack(new NodeStack()),
mo_graph(new CycleGraph()),
/** @brief Destructor */
ModelChecker::~ModelChecker()
{
- for (int i = 0; i < get_num_threads(); i++)
+ for (unsigned int i = 0; i < get_num_threads(); i++)
delete thread_map->get(i);
delete thread_map;
delete (*promises)[i];
delete promises;
- delete pending_acq_rel_seq;
+ delete pending_rel_seqs;
delete thrd_last_action;
delete node_stack;
}
/** @return the number of user threads created during this execution */
-int ModelChecker::get_num_threads()
+unsigned int ModelChecker::get_num_threads()
{
return priv->next_thread_id;
}
}
DEBUG("Number of acquires waiting on pending release sequences: %lu\n",
- pending_acq_rel_seq->size());
+ pending_rel_seqs->size());
if (isfinalfeasible() || DBG_ENABLED())
print_summary();
curr->read_from(reads_from);
mo_graph->commitChanges();
+ mo_check_promises(curr->get_tid(), reads_from);
+
updated |= r_status;
} else if (!second_part_of_rmw) {
/* Read from future value */
}
mo_graph->commitChanges();
+ mo_check_promises(curr->get_tid(), curr);
+
get_thread(curr)->set_return_value(VALUE_NONE);
return updated_mod_order || updated_promises;
}
break;
}
case THREAD_START: {
- check_promises(NULL, curr->get_cv());
+ check_promises(curr->get_tid(), NULL, curr->get_cv());
break;
}
default:
/** @return whether the current partial trace must be a prefix of a
* feasible trace. */
bool ModelChecker::isfeasibleprefix() {
- return promises->size() == 0 && pending_acq_rel_seq->size() == 0;
+ return promises->size() == 0 && pending_rel_seqs->size() == 0;
}
/** @return whether the current partial trace is feasible. */
* @todo Finish lazy updating, when promises are fulfilled in the future
* @param rf The action that might be part of a release sequence. Must be a
* write.
- * @param release_heads A pass-by-reference style return parameter. After
+ * @param release_heads A pass-by-reference style return parameter. After
* execution of this function, release_heads will contain the heads of all the
- * relevant release sequences, if any exists
+ * relevant release sequences, if any exists with certainty
+ * @param pending A pass-by-reference style return parameter which is only used
+ * when returning false (i.e., uncertain). Returns most information regarding
+ * an uncertain release sequence, including any write operations that might
+ * break the sequence.
* @return true, if the ModelChecker is certain that release_heads is complete;
* false otherwise
*/
-bool ModelChecker::release_seq_heads(const ModelAction *rf, rel_heads_list_t *release_heads) const
+bool ModelChecker::release_seq_heads(const ModelAction *rf,
+ rel_heads_list_t *release_heads,
+ struct release_seq *pending) const
{
/* Only check for release sequences if there are no cycles */
if (mo_graph->checkForCycles())
};
if (!rf) {
/* read from future: need to settle this later */
+ pending->rf = NULL;
return false; /* incomplete */
}
ASSERT(rf->same_thread(release));
+ pending->writes.clear();
+
bool certain = true;
for (unsigned int i = 0; i < thrd_lists->size(); i++) {
if (id_to_int(rf->get_tid()) == (int)i)
/* release --mo-> act --mo--> rf */
return true; /* complete */
}
+ /* act may break release sequence */
+ pending->writes.push_back(act);
certain = false;
}
if (!future_ordered)
- return false; /* This thread is uncertain */
+ certain = false; /* This thread is uncertain */
}
- if (certain)
+ if (certain) {
release_heads->push_back(release);
+ pending->writes.clear();
+ } else {
+ pending->release = release;
+ pending->rf = rf;
+ }
return certain;
}
void ModelChecker::get_release_seq_heads(ModelAction *act, rel_heads_list_t *release_heads)
{
const ModelAction *rf = act->get_reads_from();
- bool complete;
- complete = release_seq_heads(rf, release_heads);
- if (!complete) {
+ struct release_seq *sequence = (struct release_seq *)snapshot_calloc(1, sizeof(struct release_seq));
+ sequence->acquire = act;
+
+ if (!release_seq_heads(rf, release_heads, sequence)) {
/* add act to 'lazy checking' list */
- pending_acq_rel_seq->push_back(act);
+ pending_rel_seqs->push_back(sequence);
+ } else {
+ snapshot_free(sequence);
}
}
bool ModelChecker::resolve_release_sequences(void *location, work_queue_t *work_queue)
{
bool updated = false;
- std::vector<ModelAction *>::iterator it = pending_acq_rel_seq->begin();
- while (it != pending_acq_rel_seq->end()) {
- ModelAction *act = *it;
+ std::vector<struct release_seq *>::iterator it = pending_rel_seqs->begin();
+ while (it != pending_rel_seqs->end()) {
+ struct release_seq *pending = *it;
+ ModelAction *act = pending->acquire;
/* Only resolve sequences on the given location, if provided */
if (location && act->get_location() != location) {
const ModelAction *rf = act->get_reads_from();
rel_heads_list_t release_heads;
bool complete;
- complete = release_seq_heads(rf, &release_heads);
+ complete = release_seq_heads(rf, &release_heads, pending);
for (unsigned int i = 0; i < release_heads.size(); i++) {
if (!act->has_synchronized_with(release_heads[i])) {
if (act->synchronize_with(release_heads[i]))
}
}
}
- if (complete)
- it = pending_acq_rel_seq->erase(it);
- else
+ if (complete) {
+ it = pending_rel_seqs->erase(it);
+ snapshot_free(pending);
+ } else {
it++;
+ }
}
// If we resolved promises or data races, see if we have realized a data race.
bool ModelChecker::resolve_promises(ModelAction *write)
{
bool resolved = false;
+ std::vector<thread_id_t> threads_to_check;
for (unsigned int i = 0, promise_index = 0; promise_index < promises->size(); i++) {
Promise *promise = (*promises)[promise_index];
post_r_modification_order(read, write);
//Make sure the promise's value matches the write's value
ASSERT(promise->get_value() == write->get_value());
-
delete(promise);
+
promises->erase(promises->begin() + promise_index);
+ threads_to_check.push_back(read->get_tid());
+
resolved = true;
} else
promise_index++;
}
+ for(unsigned int i=0;i<threads_to_check.size();i++)
+ mo_check_promises(threads_to_check[i], write);
+
return resolved;
}
}
/** Checks promises in response to change in ClockVector Threads. */
-void ModelChecker::check_promises(ClockVector *old_cv, ClockVector *merge_cv)
+void ModelChecker::check_promises(thread_id_t tid, ClockVector *old_cv, ClockVector *merge_cv)
{
for (unsigned int i = 0; i < promises->size(); i++) {
Promise *promise = (*promises)[i];
const ModelAction *act = promise->get_action();
if ((old_cv == NULL || !old_cv->synchronized_since(act)) &&
merge_cv->synchronized_since(act)) {
- //This thread is no longer able to send values back to satisfy the promise
- int num_synchronized_threads = promise->increment_threads();
- if (num_synchronized_threads == get_num_threads()) {
+ if (promise->increment_threads(tid)) {
//Promise has failed
failed_promise = true;
return;
}
}
+/** Checks promises in response to change in ClockVector Threads. */
+void ModelChecker::mo_check_promises(thread_id_t tid, const ModelAction *write) {
+ void * location = write->get_location();
+ for (unsigned int i = 0; i < promises->size(); i++) {
+ Promise *promise = (*promises)[i];
+ const ModelAction *act = promise->get_action();
+
+ //Is this promise on the same location?
+ if ( act->get_location() != location )
+ continue;
+
+ if ( act->get_tid()==tid) {
+ if (promise->get_write() == NULL ) {
+ promise->set_write(write);
+ }
+ if (mo_graph->checkPromise(write, promise)) {
+ failed_promise = true;
+ return;
+ }
+ }
+
+ //Don't do any lookups twice for the same thread
+ if (promise->has_sync_thread(tid))
+ continue;
+
+ if (mo_graph->checkReachable(promise->get_write(), write)) {
+ if (promise->increment_threads(tid)) {
+ failed_promise = true;
+ return;
+ }
+ }
+ }
+}
+
/**
* Build up an initial set of all past writes that this 'read' action may read
* from. This set is determined by the clock vector's "happens before"