nextThread(THREAD_ID_T_NONE),
action_trace(new action_list_t()),
thread_map(new std::map<int, Thread *>),
+ obj_map(new std::map<const void *, action_list_t>()),
obj_thrd_map(new std::map<void *, std::vector<action_list_t> >()),
thrd_last_action(new std::vector<ModelAction *>(1)),
node_stack(new NodeStack()),
delete thread_map;
delete obj_thrd_map;
+ delete obj_map;
delete action_trace;
delete thrd_last_action;
delete node_stack;
DEBUG("*** Divergence point ***\n");
tid = node->get_next_backtrack();
diverge = NULL;
+ node_stack->pop_restofstack();
} else {
tid = next->get_tid();
}
action_type type = act->get_type();
switch (type) {
- case THREAD_CREATE:
- case THREAD_YIELD:
- case THREAD_JOIN:
- return NULL;
case ATOMIC_READ:
case ATOMIC_WRITE:
- default:
+ case ATOMIC_RMW:
break;
+ default:
+ return NULL;
}
/* linear search: from most recent to oldest */
+ action_list_t *list = &(*obj_map)[act->get_location()];
action_list_t::reverse_iterator rit;
- for (rit = action_trace->rbegin(); rit != action_trace->rend(); rit++) {
+ for (rit = list->rbegin(); rit != list->rend(); rit++) {
ModelAction *prev = *rit;
if (act->is_synchronizing(prev))
return prev;
set_backtracking(curr);
add_action_to_lists(curr);
+
+ /* Assign reads_from values */
+ /* TODO: perform release/acquire synchronization here; include
+ * reads_from as ModelAction member? */
+ Thread *th = get_thread(curr->get_tid());
+ uint64_t value = VALUE_NONE;
+ if (curr->is_read()) {
+ const ModelAction *reads_from = curr->get_node()->get_next_read_from();
+ value = reads_from->get_value();
+ /* Assign reads_from, perform release/acquire synchronization */
+ curr->read_from(reads_from);
+ }
+ th->set_return_value(value);
}
/**
*/
void ModelChecker::add_action_to_lists(ModelAction *act)
{
+ int tid = id_to_int(act->get_tid());
action_trace->push_back(act);
+ (*obj_map)[act->get_location()].push_back(act);
+
std::vector<action_list_t> *vec = &(*obj_thrd_map)[act->get_location()];
- if (id_to_int(act->get_tid()) >= (int)vec->size())
+ if (tid >= (int)vec->size())
vec->resize(next_thread_id);
- (*vec)[id_to_int(act->get_tid())].push_back(act);
+ (*vec)[tid].push_back(act);
- (*thrd_last_action)[id_to_int(act->get_tid())] = act;
+ if ((int)thrd_last_action->size() <= tid)
+ thrd_last_action->resize(get_num_threads());
+ (*thrd_last_action)[tid] = act;
}
ModelAction * ModelChecker::get_last_action(thread_id_t tid)
return (*thrd_last_action)[id_to_int(tid)];
}
+/**
+ * Gets the last memory_order_seq_cst action (in the total global sequence)
+ * performed on a particular object (i.e., memory location).
+ * @param location The object location to check
+ * @return The last seq_cst action performed
+ */
+ModelAction * ModelChecker::get_last_seq_cst(const void *location)
+{
+ action_list_t *list = &(*obj_map)[location];
+ /* Find: max({i in dom(S) | seq_cst(t_i) && isWrite(t_i) && samevar(t_i, t)}) */
+ action_list_t::reverse_iterator rit;
+ for (rit = list->rbegin(); rit != list->rend(); rit++)
+ if ((*rit)->is_write() && (*rit)->is_seqcst())
+ return *rit;
+ return NULL;
+}
+
ModelAction * ModelChecker::get_parent_action(thread_id_t tid)
{
ModelAction *parent = get_last_action(tid);
ASSERT(curr->is_read());
+ ModelAction *last_seq_cst = NULL;
+
/* Track whether this object has been initialized */
bool initialized = false;
+ if (curr->is_seqcst()) {
+ last_seq_cst = get_last_seq_cst(curr->get_location());
+ /* We have to at least see the last sequentially consistent write,
+ so we are initialized. */
+ if (last_seq_cst != NULL)
+ initialized = true;
+ }
+
+ /* Iterate over all threads */
for (i = 0; i < thrd_lists->size(); i++) {
+ /* Iterate over actions in thread, starting from most recent */
action_list_t *list = &(*thrd_lists)[i];
action_list_t::reverse_iterator rit;
for (rit = list->rbegin(); rit != list->rend(); rit++) {
if (!act->is_write())
continue;
- DEBUG("Adding action to may_read_from:\n");
- if (DBG_ENABLED()) {
- act->print();
- curr->print();
+ /* Don't consider more than one seq_cst write */
+ if (!act->is_seqcst() || act == last_seq_cst) {
+ DEBUG("Adding action to may_read_from:\n");
+ if (DBG_ENABLED()) {
+ act->print();
+ curr->print();
+ }
+ curr->get_node()->add_read_from(act);
}
- curr->get_node()->add_read_from(act);
/* Include at most one act per-thread that "happens before" curr */
if (act->happens_before(curr)) {
/* TODO: need a more informative way of reporting errors */
printf("ERROR: may read from uninitialized atomic\n");
}
-
+
if (DBG_ENABLED() || !initialized) {
printf("Reached read action:\n");
curr->print();
curr->get_node()->print_may_read_from();
printf("End printing may_read_from\n");
}
-
+
ASSERT(initialized);
}
scheduler->remove_thread(t);
}
+/**
+ * Switch from a user-context to the "master thread" context (a.k.a. system
+ * context). This switch is made with the intention of exploring a particular
+ * model-checking action (described by a ModelAction object). Must be called
+ * from a user-thread context.
+ * @param act The current action that will be explored. May be NULL, although
+ * there is little reason to switch to the model-checker without an action to
+ * explore (note: act == NULL is sometimes used as a hack to allow a thread to
+ * yield control without performing any progress; see thrd_join()).
+ * @return Return status from the 'swap' call (i.e., success/fail, 0/-1)
+ */
int ModelChecker::switch_to_master(ModelAction *act)
{
Thread *old;