From: Martin Quinson Date: Sun, 12 Nov 2023 14:01:06 +0000 (+0100) Subject: Merge branch 'master' of framagit.org:simgrid/simgrid X-Git-Tag: v3.35~77 X-Git-Url: http://bilbo.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/commitdiff_plain/a0d47b6eaf07218a602ed6606da925fbd3629909?hp=-c Merge branch 'master' of framagit.org:simgrid/simgrid --- a0d47b6eaf07218a602ed6606da925fbd3629909 diff --combined src/mc/explo/odpor/ReversibleRaceCalculator.cpp index d35c167d67,5fcb30e2c3..575d8e048e --- a/src/mc/explo/odpor/ReversibleRaceCalculator.cpp +++ b/src/mc/explo/odpor/ReversibleRaceCalculator.cpp @@@ -29,7 -29,7 +29,7 @@@ bool ReversibleRaceCalculator::is_race_ Execution::EventHandle e2) { using Action = Transition::Type; - using Handler = std::function; + using Handler = std::function; using HandlerMap = std::unordered_map; const static HandlerMap handlers = { @@@ -53,10 -53,9 +53,10 @@@ {Action::TESTANY, &ReversibleRaceCalculator::is_race_reversible_TestAny}, {Action::WAITANY, &ReversibleRaceCalculator::is_race_reversible_WaitAny}}; - const auto* e2_action = E.get_transition_for_handle(e2); - if (const auto handler = handlers.find(e2_action->type_); handler != handlers.end()) { - return handler->second(E, e1, e2_action); + const auto* other_transition = E.get_transition_for_handle(e1); + const auto* t2 = E.get_transition_for_handle(e2); + if (const auto handler = handlers.find(t2->type_); handler != handlers.end()) { + return handler->second(E, other_transition, t2); } else { xbt_die("There is currently no specialized computation for the transition " "'%s' for computing reversible races in ODPOR, so the model checker cannot " @@@ -64,12 -63,12 +64,12 @@@ "that the transition be supported in SimGrid using ODPPR and consider " "using the other model-checking algorithms supported by SimGrid instead " "in the meantime", - e2_action->to_string().c_str()); + t2->to_string().c_str()); } } -bool ReversibleRaceCalculator::is_race_reversible_ActorJoin(const Execution&, Execution::EventHandle /*e1*/, - const Transition* /*e2*/) +bool ReversibleRaceCalculator::is_race_reversible_ActorJoin(const Execution&, const Transition* /*other_transition*/, + const Transition* /*t2*/) { // ActorJoin races with another event iff its target `T` is the same as // the actor executing the other transition. Clearly, then, we could not join @@@ -77,139 -76,139 +77,140 @@@ return false; } -bool ReversibleRaceCalculator::is_race_reversible_BarrierAsyncLock(const Execution&, Execution::EventHandle /*e1*/, - const Transition* /*e2*/) +bool ReversibleRaceCalculator::is_race_reversible_BarrierAsyncLock(const Execution&, + const Transition* /*other_transition*/, + const Transition* /*t2*/) { // BarrierAsyncLock is always enabled return true; } -bool ReversibleRaceCalculator::is_race_reversible_BarrierWait(const Execution& E, Execution::EventHandle e1, - const Transition* /*e2*/) +bool ReversibleRaceCalculator::is_race_reversible_BarrierWait(const Execution& E, const Transition* other_transition, + const Transition* /*t2*/) { // If the other event is a barrier lock event, then we // are not reversible; otherwise we are reversible. - const auto e1_action = E.get_transition_for_handle(e1)->type_; - return e1_action != Transition::Type::BARRIER_ASYNC_LOCK; + const auto other_action = other_transition->type_; + return other_action != Transition::Type::BARRIER_ASYNC_LOCK; } -bool ReversibleRaceCalculator::is_race_reversible_CommRecv(const Execution&, Execution::EventHandle /*e1*/, - const Transition* /*e2*/) +bool ReversibleRaceCalculator::is_race_reversible_CommRecv(const Execution&, const Transition* /*other_transition*/, + const Transition* /*t2*/) { // CommRecv is always enabled return true; } -bool ReversibleRaceCalculator::is_race_reversible_CommSend(const Execution&, Execution::EventHandle /*e1*/, - const Transition* /*e2*/) +bool ReversibleRaceCalculator::is_race_reversible_CommSend(const Execution&, const Transition* /*other_transition*/, + const Transition* /*t2*/) { // CommSend is always enabled return true; } -bool ReversibleRaceCalculator::is_race_reversible_CommWait(const Execution& E, Execution::EventHandle e1, - const Transition* /*e2*/) +bool ReversibleRaceCalculator::is_race_reversible_CommWait(const Execution& E, const Transition* other_transition, + const Transition* /*t2*/) { // If the other event is a communication event, then we // are not reversible; otherwise we are reversible. - const auto e1_action = E.get_transition_for_handle(e1)->type_; - return e1_action != Transition::Type::COMM_ASYNC_SEND && e1_action != Transition::Type::COMM_ASYNC_RECV; + const auto other_action = other_transition->type_; + return other_action != Transition::Type::COMM_ASYNC_SEND && other_action != Transition::Type::COMM_ASYNC_RECV; } -bool ReversibleRaceCalculator::is_race_reversible_CommTest(const Execution&, Execution::EventHandle /*e1*/, - const Transition* /*e2*/) +bool ReversibleRaceCalculator::is_race_reversible_CommTest(const Execution&, const Transition* /*other_transition*/, + const Transition* /*t2*/) { // CommTest is always enabled return true; } -bool ReversibleRaceCalculator::is_race_reversible_MutexAsyncLock(const Execution&, Execution::EventHandle /*e1*/, - const Transition* /*e2*/) +bool ReversibleRaceCalculator::is_race_reversible_MutexAsyncLock(const Execution&, + const Transition* /*other_transition*/, + const Transition* /*t2*/) { // MutexAsyncLock is always enabled return true; } -bool ReversibleRaceCalculator::is_race_reversible_MutexTest(const Execution&, Execution::EventHandle /*e1*/, - const Transition* /*e2*/) +bool ReversibleRaceCalculator::is_race_reversible_MutexTest(const Execution&, const Transition* /*other_transition*/, + const Transition* /*t2*/) { // MutexTest is always enabled return true; } -bool ReversibleRaceCalculator::is_race_reversible_MutexTrylock(const Execution&, Execution::EventHandle /*e1*/, - const Transition* /*e2*/) +bool ReversibleRaceCalculator::is_race_reversible_MutexTrylock(const Execution&, const Transition* /*other_transition*/, + const Transition* /*t2*/) { // MutexTrylock is always enabled return true; } -bool ReversibleRaceCalculator::is_race_reversible_MutexUnlock(const Execution&, Execution::EventHandle /*e1*/, - const Transition* /*e2*/) +bool ReversibleRaceCalculator::is_race_reversible_MutexUnlock(const Execution&, const Transition* /*other_transition*/, + const Transition* /*t2*/) { // MutexUnlock is always enabled return true; } -bool ReversibleRaceCalculator::is_race_reversible_MutexWait(const Execution& E, Execution::EventHandle e1, - const Transition* /*e2*/) +bool ReversibleRaceCalculator::is_race_reversible_MutexWait(const Execution& E, const Transition* /*other_transition*/, + const Transition* /*t2*/) { - // TODO: for now we over approximate the reversibility - - return true; + // Only an Unlock can be dependent with a Wait + // and in this case, the Unlock enbaled the wait + // Not reversibled + return false; } -bool ReversibleRaceCalculator::is_race_reversible_SemAsyncLock(const Execution&, Execution::EventHandle /*e1*/, - const Transition* /*e2*/) +bool ReversibleRaceCalculator::is_race_reversible_SemAsyncLock(const Execution&, const Transition* /*other_transition*/, + const Transition* /*t2*/) { // SemAsyncLock is always enabled return true; } -bool ReversibleRaceCalculator::is_race_reversible_SemUnlock(const Execution&, Execution::EventHandle /*e1*/, - const Transition* /*e2*/) +bool ReversibleRaceCalculator::is_race_reversible_SemUnlock(const Execution&, const Transition* /*other_transition*/, + const Transition* /*t2*/) { // SemUnlock is always enabled return true; } -bool ReversibleRaceCalculator::is_race_reversible_SemWait(const Execution& E, Execution::EventHandle e1, - const Transition* /*e2*/) +bool ReversibleRaceCalculator::is_race_reversible_SemWait(const Execution& E, const Transition* other_transition, + const Transition* /*t2*/) { - const auto e1_transition = E.get_transition_for_handle(e1); - if (e1_transition->type_ == Transition::Type::SEM_UNLOCK && - static_cast(e1_transition)->get_capacity() <= 1) { + if (other_transition->type_ == Transition::Type::SEM_UNLOCK && + static_cast(other_transition)->get_capacity() <= 1) { return false; } - xbt_assert(false, "SEM_WAIT that is dependent with a SEM_UNLOCK should not be reversible. FixMe"); + xbt_die("SEM_WAIT that is dependent with a SEM_UNLOCK should not be reversible. FixMe"); return true; } -bool ReversibleRaceCalculator::is_race_reversible_ObjectAccess(const Execution&, Execution::EventHandle /*e1*/, - const Transition* /*e2*/) +bool ReversibleRaceCalculator::is_race_reversible_ObjectAccess(const Execution&, const Transition* /*other_transition*/, + const Transition* /*t2*/) { // Object access is always enabled return true; } -bool ReversibleRaceCalculator::is_race_reversible_Random(const Execution&, Execution::EventHandle /*e1*/, - const Transition* /*e2*/) +bool ReversibleRaceCalculator::is_race_reversible_Random(const Execution&, const Transition* /*other_transition*/, + const Transition* /*t2*/) { // Random is always enabled return true; } -bool ReversibleRaceCalculator::is_race_reversible_TestAny(const Execution&, Execution::EventHandle /*e1*/, - const Transition* /*e2*/) +bool ReversibleRaceCalculator::is_race_reversible_TestAny(const Execution&, const Transition* /*other_transition*/, + const Transition* /*t2*/) { // TestAny is always enabled return true; } -bool ReversibleRaceCalculator::is_race_reversible_WaitAny(const Execution&, Execution::EventHandle /*e1*/, - const Transition* /*e2*/) +bool ReversibleRaceCalculator::is_race_reversible_WaitAny(const Execution&, const Transition* /*other_transition*/, + const Transition* /*t2*/) { // TODO: We need to check if any of the transitions // waited on occurred before `e1`