X-Git-Url: http://plrg.eecs.uci.edu/git/?p=c11tester.git;a=blobdiff_plain;f=model.cc;h=f5dd7cbda419209acf023c27d340218d146ebcff;hp=465849afa03b5a0946236528b8aea7f7703940b4;hb=18c6031154215ab85ad74fe70deb50ac8e3cbdf6;hpb=63e202b2db7a90e176db54c864d2e54ec535c03f diff --git a/model.cc b/model.cc index 465849af..f5dd7cbd 100644 --- a/model.cc +++ b/model.cc @@ -48,6 +48,7 @@ struct model_snapshot_members { stats(), failed_promise(false), too_many_reads(false), + no_valid_reads(false), bad_synchronization(false), asserted(false) { } @@ -66,6 +67,7 @@ struct model_snapshot_members { struct execution_stats stats; bool failed_promise; bool too_many_reads; + bool no_valid_reads; /** @brief Incorrectly-ordered synchronization was made */ bool bad_synchronization; bool asserted; @@ -294,7 +296,6 @@ void ModelChecker::execute_sleep_set() thread_id_t tid = int_to_id(i); Thread *thr = get_thread(tid); if (scheduler->is_sleep_set(thr) && thr->get_pending() == NULL) { - thr->set_state(THREAD_RUNNING); scheduler->next_thread(thr); Thread::swap(&system_context, thr); priv->current_action->set_sleep_flag(); @@ -729,7 +730,7 @@ bool ModelChecker::process_read(ModelAction *curr, bool second_part_of_rmw) read_from(curr, reads_from); mo_graph->commitChanges(); - mo_check_promises(curr->get_tid(), reads_from, NULL); + mo_check_promises(curr, true); updated |= r_status; } else if (!second_part_of_rmw) { @@ -895,7 +896,7 @@ bool ModelChecker::process_write(ModelAction *curr) } mo_graph->commitChanges(); - mo_check_promises(curr->get_tid(), curr, NULL); + mo_check_promises(curr, false); get_thread(curr)->set_return_value(VALUE_NONE); return updated_mod_order || updated_promises; @@ -968,7 +969,10 @@ bool ModelChecker::process_thread_action(ModelAction *curr) switch (curr->get_type()) { case THREAD_CREATE: { - Thread *th = curr->get_thread_operand(); + thrd_t *thrd = (thrd_t *)curr->get_location(); + struct thread_params *params = (struct thread_params *)curr->get_value(); + Thread *th = new Thread(thrd, params->func, params->arg); + add_thread(th); th->set_creation(curr); /* Promises can be satisfied by children */ for (unsigned int i = 0; i < promises->size(); i++) { @@ -1387,6 +1391,8 @@ void ModelChecker::print_infeasibility(const char *prefix) const ptr += sprintf(ptr, "[failed promise]"); if (priv->too_many_reads) ptr += sprintf(ptr, "[too many reads]"); + if (priv->no_valid_reads) + ptr += sprintf(ptr, "[no valid reads-from]"); if (priv->bad_synchronization) ptr += sprintf(ptr, "[bad sw ordering]"); if (promises_expired()) @@ -1415,6 +1421,7 @@ bool ModelChecker::is_feasible_prefix_ignore_relseq() const bool ModelChecker::is_infeasible() const { return mo_graph->checkForCycles() || + priv->no_valid_reads || priv->failed_promise || priv->too_many_reads || priv->bad_synchronization || @@ -1425,8 +1432,11 @@ bool ModelChecker::is_infeasible() const ModelAction * ModelChecker::process_rmw(ModelAction *act) { ModelAction *lastread = get_last_action(act->get_tid()); lastread->process_rmw(act); - if (act->is_rmw() && lastread->get_reads_from() != NULL) { - mo_graph->addRMWEdge(lastread->get_reads_from(), lastread); + if (act->is_rmw()) { + if (lastread->get_reads_from()) + mo_graph->addRMWEdge(lastread->get_reads_from(), lastread); + else + mo_graph->addRMWEdge(lastread->get_reads_from_promise(), lastread); mo_graph->commitChanges(); } return lastread; @@ -1491,13 +1501,9 @@ void ModelChecker::check_recency(ModelAction *curr, const ModelAction *rf) continue; /* Test to see whether this is a feasible write to read from */ - mo_graph->startChanges(); - r_modification_order(curr, write); - bool feasiblereadfrom = !is_infeasible(); - mo_graph->rollbackChanges(); + /** NOTE: all members of read-from set should be + * feasible, so we no longer check it here **/ - if (!feasiblereadfrom) - continue; rit = ritcopy; bool feasiblewrite = true; @@ -1616,71 +1622,15 @@ bool ModelChecker::r_modification_order(ModelAction *curr, const rf_type *rf) } } - return added; -} - -/** 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 *thrd_lists = get_safe_ptr_vect_action(obj_thrd_map, curr->get_location()); - unsigned int i; - ASSERT(curr->is_read()); - - /* 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; - ModelAction *lastact = NULL; - - /* Find last action that happens after curr that is either not curr or a rmw */ - for (rit = list->rbegin(); rit != list->rend(); rit++) { - ModelAction *act = *rit; - if (curr->happens_before(act) && (curr != act || curr->is_rmw())) { - lastact = act; - } else - break; - } + /* + * All compatible, thread-exclusive promises must be ordered after any + * concrete loads from the same thread + */ + for (unsigned int i = 0; i < promises->size(); i++) + if ((*promises)[i]->is_compatible_exclusive(curr)) + added = mo_graph->addEdge(rf, (*promises)[i]) || added; - /* Include at most one act per-thread that "happens before" curr */ - if (lastact != NULL) { - if (lastact == curr) { - //Case 1: The resolved read is a RMW, and we need to make sure - //that the write portion of the RMW mod order after rf - - mo_graph->addEdge(rf, lastact); - } else if (lastact->is_read()) { - //Case 2: The resolved read is a normal read and the next - //operation is a read, and we need to make sure the value read - //is mod ordered after rf - - const ModelAction *postreadfrom = lastact->get_reads_from(); - if (postreadfrom != NULL && rf != postreadfrom) - mo_graph->addEdge(rf, postreadfrom); - } else { - //Case 3: The resolved read is a normal read and the next - //operation is a write, and we need to make sure that the - //write is mod ordered after rf - if (lastact != rf) - mo_graph->addEdge(rf, lastact); - } - break; - } - } + return added; } /** @@ -2333,25 +2283,18 @@ bool ModelChecker::resolve_promises(ModelAction *write) { bool haveResolved = false; std::vector< ModelAction *, ModelAlloc > actions_to_check; + promise_list_t mustResolve, resolved; for (unsigned int i = 0, promise_index = 0; promise_index < promises->size(); i++) { Promise *promise = (*promises)[promise_index]; if (write->get_node()->get_promise(i)) { ModelAction *read = promise->get_action(); - if (read->is_rmw()) { - mo_graph->addRMWEdge(write, read); - } read_from(read, write); - //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); //Make sure the promise's value matches the write's value ASSERT(promise->is_compatible(write)); - delete promise; + mo_graph->resolvePromise(read, write, &mustResolve); + resolved.push_back(promise); promises->erase(promises->begin() + promise_index); actions_to_check.push_back(read); @@ -2360,12 +2303,19 @@ bool ModelChecker::resolve_promises(ModelAction *write) promise_index++; } + for (unsigned int i = 0; i < mustResolve.size(); i++) { + if (std::find(resolved.begin(), resolved.end(), mustResolve[i]) + == resolved.end()) + priv->failed_promise = true; + } + for (unsigned int i = 0; i < resolved.size(); i++) + delete resolved[i]; //Check whether reading these writes has made threads unable to //resolve promises for (unsigned int i = 0; i < actions_to_check.size(); i++) { ModelAction *read = actions_to_check[i]; - mo_check_promises(read->get_tid(), write, read); + mo_check_promises(read, true); } return haveResolved; @@ -2425,71 +2375,39 @@ void ModelChecker::check_promises_thread_disabled() * @brief Checks promises in response to addition to modification order for * threads. * - * Definitions: - * - * pthread is the thread that performed the read that created the promise - * - * pread is the read that created the promise - * - * pwrite is either the first write to same location as pread by - * pthread that is sequenced after pread or the write read by the - * first read to the same location as pread by pthread that is - * sequenced after pread. - * - * 1. If tid=pthread, then we check what other threads are reachable - * through the mod order starting with pwrite. Those threads cannot - * perform a write that will resolve the promise due to modification - * order constraints. + * We test whether threads are still available for satisfying promises after an + * addition to our modification order constraints. Those that are unavailable + * are "eliminated". Once all threads are eliminated from satisfying a promise, + * that promise has failed. * - * 2. If the tid is not pthread, we check whether pwrite can reach the - * action write through the modification order. If so, that thread - * cannot perform a future write that will resolve the promise due to - * modificatin order constraints. - * - * @param tid The thread that either read from the model action write, or - * actually did the model action write. - * - * @param write The ModelAction representing the relevant write. - * @param read The ModelAction that reads a promised write, or NULL otherwise. + * @param act The ModelAction which updated the modification order + * @param is_read_check Should be true if act is a read and we must check for + * updates to the store from which it read (there is a distinction here for + * RMW's, which are both a load and a store) */ -void ModelChecker::mo_check_promises(thread_id_t tid, const ModelAction *write, const ModelAction *read) +void ModelChecker::mo_check_promises(const ModelAction *act, bool is_read_check) { - void *location = write->get_location(); + const ModelAction *write = is_read_check ? act->get_reads_from() : act; + for (unsigned int i = 0; i < promises->size(); i++) { Promise *promise = (*promises)[i]; - const ModelAction *act = promise->get_action(); + const ModelAction *pread = promise->get_action(); // Is this promise on the same location? - if (act->get_location() != location) + if (!pread->same_var(write)) continue; - // same thread as the promise - if (act->get_tid() == tid) { - // make sure that the reader of this write happens after the promise - if ((read == NULL) || (promise->get_action()->happens_before(read))) { - // do we have a pwrite for the promise, if not, set it - if (promise->get_write() == NULL) { - promise->set_write(write); - // The pwrite cannot happen before the promise - if (write->happens_before(act) && (write != act)) { - priv->failed_promise = true; - return; - } - } - - if (mo_graph->checkPromise(write, promise)) { - priv->failed_promise = true; - return; - } - } + if (pread->happens_before(act) && mo_graph->checkPromise(write, promise)) { + priv->failed_promise = true; + return; } // Don't do any lookups twice for the same thread - if (!promise->thread_is_available(tid)) + if (!promise->thread_is_available(act->get_tid())) continue; - if (promise->get_write() && mo_graph->checkReachable(promise->get_write(), write)) { - if (promise->eliminate_thread(tid)) { + if (mo_graph->checkReachable(promise, write)) { + if (mo_graph->checkPromise(write, promise)) { priv->failed_promise = true; return; } @@ -2558,14 +2476,25 @@ void ModelChecker::build_reads_from_past(ModelAction *curr) else if (curr->get_sleep_flag() && !curr->is_seqcst() && !sleep_can_read_from(curr, act)) allow_read = false; - if (allow_read) - curr->get_node()->add_read_from(act); + if (allow_read) { + /* Only add feasible reads */ + mo_graph->startChanges(); + r_modification_order(curr, act); + if (!is_infeasible()) + curr->get_node()->add_read_from(act); + mo_graph->rollbackChanges(); + } /* Include at most one act per-thread that "happens before" curr */ if (act->happens_before(curr)) break; } } + /* We may find no valid may-read-from only if the execution is doomed */ + if (!curr->get_node()->get_read_from_size()) { + priv->no_valid_reads = true; + set_assert(); + } if (DBG_ENABLED()) { model_print("Reached read action:\n"); @@ -2638,7 +2567,7 @@ void ModelChecker::dumpGraph(char *filename) const for (action_list_t::iterator it = action_trace->begin(); it != action_trace->end(); it++) { ModelAction *action = *it; if (action->is_read()) { - fprintf(file, "N%u [label=\"%u, T%u\"];\n", action->get_seq_number(), action->get_seq_number(), action->get_tid()); + fprintf(file, "N%u [label=\"N%u, T%u\"];\n", action->get_seq_number(), action->get_seq_number(), action->get_tid()); if (action->get_reads_from() != NULL) fprintf(file, "N%u -> N%u[label=\"rf\", color=red];\n", action->get_seq_number(), action->get_reads_from()->get_seq_number()); } @@ -2750,7 +2679,6 @@ uint64_t ModelChecker::switch_to_master(ModelAction *act) DBG(); Thread *old = thread_current(); set_current_action(act); - old->set_state(THREAD_READY); if (Thread::swap(old, &system_context) < 0) { perror("swap threads"); exit(EXIT_FAILURE); @@ -2761,12 +2689,13 @@ uint64_t ModelChecker::switch_to_master(ModelAction *act) /** * Takes the next step in the execution, if possible. * @param curr The current step to take - * @return Returns true (success) if a step was taken and false otherwise. + * @return Returns the next Thread to run, if any; NULL if this execution + * should terminate */ -bool ModelChecker::take_step(ModelAction *curr) +Thread * ModelChecker::take_step(ModelAction *curr) { if (has_asserted()) - return false; + return NULL; Thread *curr_thrd = get_thread(curr); ASSERT(curr_thrd->get_state() == THREAD_READY); @@ -2775,15 +2704,14 @@ bool ModelChecker::take_step(ModelAction *curr) /* Infeasible -> don't take any more steps */ if (is_infeasible()) - return false; + return NULL; else if (isfeasibleprefix() && have_bug_reports()) { set_assert(); - return false; + return NULL; } - if (params.bound != 0) - if (priv->used_sequence_numbers > params.bound) - return false; + if (params.bound != 0 && priv->used_sequence_numbers > params.bound) + return NULL; if (curr_thrd->is_blocked() || curr_thrd->is_complete()) scheduler->remove_thread(curr_thrd); @@ -2811,25 +2739,21 @@ bool ModelChecker::take_step(ModelAction *curr) std::memory_order_seq_cst, NULL, VALUE_NONE, model_thread); set_current_action(fixup); - return true; + return model_thread; } /* next_thrd == NULL -> don't take any more steps */ if (!next_thrd) - return false; - - next_thrd->set_state(THREAD_RUNNING); + return NULL; if (next_thrd->get_pending() != NULL) { /* restart a pending action */ set_current_action(next_thrd->get_pending()); next_thrd->set_pending(NULL); - next_thrd->set_state(THREAD_READY); - return true; + return next_thrd; } - /* Return false only if swap fails with an error */ - return (Thread::swap(&system_context, next_thrd) == 0); + return next_thrd; } /** Wrapper to run the user's main function, with appropriate arguments */ @@ -2844,15 +2768,14 @@ void ModelChecker::run() do { thrd_t user_thread; Thread *t = new Thread(&user_thread, &user_main_wrapper, NULL); - add_thread(t); - /* Run user thread up to its first action */ - scheduler->next_thread(t); - Thread::swap(&system_context, t); - - /* Wait for all threads to complete */ - while (take_step(priv->current_action)); + do { + scheduler->next_thread(t); + Thread::swap(&system_context, t); + t = take_step(priv->current_action); + } while (t && !t->is_model_thread()); + /** @TODO Re-write release sequence fixups here */ } while (next_execution()); print_stats();