#include "src/kernel/activity/MailboxImpl.hpp"
#include "src/kernel/activity/MutexImpl.hpp"
+#include "src/kernel/actor/SimcallObserver.hpp"
#include "src/mc/Session.hpp"
#include "src/mc/checker/Checker.hpp"
-#include "src/mc/checker/SimcallObserver.hpp"
#include "src/mc/mc_comm_pattern.hpp"
#include "src/mc/mc_exit.hpp"
#include "src/mc/mc_pattern.hpp"
#include "src/mc/mc_private.hpp"
#include "src/mc/remote/RemoteProcess.hpp"
+#include "src/surf/HostImpl.hpp"
#include <xbt/asserts.h>
#include <xbt/log.h>
static void simcall_translate(smx_simcall_t req,
simgrid::mc::Remote<simgrid::kernel::activity::CommImpl>& buffered_comm);
+static bool request_is_enabled_by_idx(const RemoteProcess& process, smx_simcall_t req, unsigned int idx)
+{
+ kernel::activity::CommImpl* remote_act = nullptr;
+ switch (req->call_) {
+ case Simcall::COMM_WAIT:
+ /* FIXME: check also that src and dst processes are not suspended */
+ remote_act = simcall_comm_wait__getraw__comm(req);
+ break;
+
+ case Simcall::COMM_WAITANY:
+ remote_act = process.read(remote(simcall_comm_waitany__get__comms(req) + idx));
+ break;
+
+ case Simcall::COMM_TESTANY:
+ remote_act = process.read(remote(simcall_comm_testany__get__comms(req) + idx));
+ break;
+
+ default:
+ return true;
+ }
+
+ Remote<kernel::activity::CommImpl> temp_comm;
+ process.read(temp_comm, remote(remote_act));
+ const kernel::activity::CommImpl* comm = temp_comm.get_buffer();
+ return comm->src_actor_.get() && comm->dst_actor_.get();
+}
+
/* Search an enabled transition for the given process.
*
* This can be seen as an iterator returning the next transition of the process.
* Things can get muddled with the WAITANY and TESTANY simcalls, that are rewritten on the fly to a bunch of WAIT
* (resp TEST) transitions using the transition.argument field to remember what was the last returned sub-transition.
*/
-static inline smx_simcall_t MC_state_choose_request_for_process(simgrid::mc::State* state, smx_actor_t actor)
+static inline smx_simcall_t MC_state_choose_request_for_process(const RemoteProcess& process, simgrid::mc::State* state,
+ smx_actor_t actor)
{
/* reset the outgoing transition */
simgrid::mc::ActorState* procstate = &state->actor_states_[actor->get_pid()];
- state->transition_.pid_ = -1;
+ state->transition_.aid_ = -1;
state->transition_.times_considered_ = -1;
state->transition_.textual[0] = '\0';
state->executed_req_.call_ = Simcall::NONE;
case Simcall::COMM_WAITANY:
state->transition_.times_considered_ = -1;
while (procstate->times_considered < simcall_comm_waitany__get__count(&actor->simcall_)) {
- if (simgrid::mc::request_is_enabled_by_idx(&actor->simcall_, procstate->times_considered)) {
+ if (simgrid::mc::request_is_enabled_by_idx(process, &actor->simcall_, procstate->times_considered)) {
state->transition_.times_considered_ = procstate->times_considered;
++procstate->times_considered;
break;
case Simcall::COMM_TESTANY:
state->transition_.times_considered_ = -1;
while (procstate->times_considered < simcall_comm_testany__get__count(&actor->simcall_)) {
- if (simgrid::mc::request_is_enabled_by_idx(&actor->simcall_, procstate->times_considered)) {
+ if (simgrid::mc::request_is_enabled_by_idx(process, &actor->simcall_, procstate->times_considered)) {
state->transition_.times_considered_ = procstate->times_considered;
++procstate->times_considered;
break;
simgrid::mc::RemotePtr<simgrid::kernel::activity::CommImpl> remote_act =
remote(simcall_comm_wait__get__comm(&actor->simcall_));
simgrid::mc::Remote<simgrid::kernel::activity::CommImpl> temp_act;
- mc_model_checker->get_remote_process().read(temp_act, remote_act);
+ process.read(temp_act, remote_act);
const simgrid::kernel::activity::CommImpl* act = temp_act.get_buffer();
if (act->src_actor_.get() && act->dst_actor_.get())
state->transition_.times_considered_ = 0; // OK
if (not req)
return nullptr;
- state->transition_.pid_ = actor->get_pid();
+ state->transition_.aid_ = actor->get_pid();
state->executed_req_ = *req;
// Fetch the data of the request and translate it:
// Read the simgrid::xbt::string in the MCed process:
simgrid::mc::ActorInformation* info = actor_info_cast(actor);
- auto remote_string_address =
- remote(reinterpret_cast<const simgrid::xbt::string_data*>(&actor->get_host()->get_name()));
- simgrid::xbt::string_data remote_string = process->read(remote_string_address);
- std::vector<char> hostname(remote_string.len + 1);
- // no need to read the terminating null byte, and thus hostname[remote_string.len] is guaranteed to be '\0'
- process->read_bytes(hostname.data(), remote_string.len, remote(remote_string.data));
- info->hostname = &mc_model_checker->get_host_name(hostname.data());
+
+ if (not info->hostname) {
+ Remote<s4u::Host> temp_host = process->read(remote(actor->get_host()));
+ auto remote_string_address = remote(&xbt::string::to_string_data(temp_host.get_buffer()->get_impl()->get_name()));
+ simgrid::xbt::string_data remote_string = process->read(remote_string_address);
+ std::vector<char> hostname(remote_string.len + 1);
+ // no need to read the terminating null byte, and thus hostname[remote_string.len] is guaranteed to be '\0'
+ process->read_bytes(hostname.data(), remote_string.len, remote(remote_string.data));
+ info->hostname = &mc_model_checker->get_host_name(hostname.data());
+ }
return *info->hostname;
}
-std::string Api::get_actor_name(smx_actor_t actor) const
+xbt::string const& Api::get_actor_name(smx_actor_t actor) const
{
if (mc_model_checker == nullptr)
- return actor->get_cname();
+ return actor->get_name();
simgrid::mc::ActorInformation* info = actor_info_cast(actor);
if (info->name.empty()) {
if (actor) {
res = "(" + std::to_string(actor->get_pid()) + ")";
if (actor->get_host())
- res += std::string(get_actor_host_name(actor)) + " (" + get_actor_name(actor) + ")";
+ res += std::string(get_actor_host_name(actor)) + " (" + std::string(get_actor_name(actor)) + ")";
else
res += get_actor_name(actor);
} else
simgrid::mc::Checker* Api::initialize(char** argv, simgrid::mc::CheckerAlgorithm algo) const
{
- simgrid::mc::session = new simgrid::mc::Session([argv] {
+ auto session = new simgrid::mc::Session([argv] {
int i = 1;
while (argv[i] != nullptr && argv[i][0] == '-')
i++;
xbt_assert(argv[i] != nullptr,
"Unable to find a binary to exec on the command line. Did you only pass config flags?");
execvp(argv[i], argv + i);
- xbt_die("The model-checked process failed to exec(): %s", strerror(errno));
+ xbt_die("The model-checked process failed to exec(%s): %s", argv[i], strerror(errno));
});
simgrid::mc::Checker* checker;
switch (algo) {
case CheckerAlgorithm::CommDeterminism:
- checker = simgrid::mc::createCommunicationDeterminismChecker(session);
+ checker = simgrid::mc::create_communication_determinism_checker(session);
break;
case CheckerAlgorithm::UDPOR:
- checker = simgrid::mc::createUdporChecker(session);
+ checker = simgrid::mc::create_udpor_checker(session);
break;
case CheckerAlgorithm::Safety:
- checker = simgrid::mc::createSafetyChecker(session);
+ checker = simgrid::mc::create_safety_checker(session);
break;
case CheckerAlgorithm::Liveness:
- checker = simgrid::mc::createLivenessChecker(session);
+ checker = simgrid::mc::create_liveness_checker(session);
break;
default:
THROW_IMPOSSIBLE;
}
+ // FIXME: session and checker are never deleted
+ simgrid::mc::session_singleton = session;
mc_model_checker->setChecker(checker);
return checker;
}
return mc_model_checker->get_remote_process().actors();
}
-bool Api::actor_is_enabled(aid_t pid) const
-{
- return session->actor_is_enabled(pid);
-}
-
unsigned long Api::get_maxpid() const
{
- static const char* name = nullptr;
- if (not name) {
- name = "simgrid::kernel::actor::maxpid";
- if (mc_model_checker->get_remote_process().find_variable(name) == nullptr)
- name = "maxpid"; // We seem to miss the namespaces when compiling with GCC
- }
- unsigned long maxpid;
- mc_model_checker->get_remote_process().read_variable(name, &maxpid, sizeof(maxpid));
- return maxpid;
+ return mc_model_checker->get_remote_process().get_maxpid();
}
int Api::get_actors_size() const
#if HAVE_SMPI
bool Api::check_send_request_detached(smx_simcall_t const& simcall) const
{
- simgrid::smpi::Request mpi_request;
+ Remote<simgrid::smpi::Request> mpi_request;
mc_model_checker->get_remote_process().read(
- &mpi_request, remote(static_cast<smpi::Request*>(simcall_comm_isend__get__data(simcall))));
- return mpi_request.detached();
+ mpi_request, remote(static_cast<smpi::Request*>(simcall_comm_isend__get__data(simcall))));
+ return mpi_request.get_buffer()->detached();
}
#endif
return heap_bytes_used;
}
-void Api::session_initialize() const
-{
- session->initialize();
-}
-
void Api::mc_inc_visited_states() const
{
mc_model_checker->visited_states++;
smx_simcall_t Api::mc_state_choose_request(simgrid::mc::State* state) const
{
- for (auto& actor : mc_model_checker->get_remote_process().actors()) {
+ RemoteProcess& process = mc_model_checker->get_remote_process();
+ for (auto& actor : process.actors()) {
/* Only consider the actors that were marked as interleaving by the checker algorithm */
if (not state->actor_states_[actor.copy.get_buffer()->get_pid()].is_todo())
continue;
- smx_simcall_t res = MC_state_choose_request_for_process(state, actor.copy.get_buffer());
+ smx_simcall_t res = MC_state_choose_request_for_process(process, state, actor.copy.get_buffer());
if (res)
return res;
}
#if HAVE_SMPI
int Api::get_smpi_request_tag(smx_simcall_t const& simcall, simgrid::simix::Simcall type) const
{
- simgrid::smpi::Request mpi_request;
void* simcall_data = nullptr;
if (type == Simcall::COMM_ISEND)
simcall_data = simcall_comm_isend__get__data(simcall);
else if (type == Simcall::COMM_IRECV)
simcall_data = simcall_comm_irecv__get__data(simcall);
- mc_model_checker->get_remote_process().read(&mpi_request, remote(static_cast<smpi::Request*>(simcall_data)));
- return mpi_request.tag();
+ Remote<simgrid::smpi::Request> mpi_request;
+ mc_model_checker->get_remote_process().read(mpi_request, remote(static_cast<smpi::Request*>(simcall_data)));
+ return mpi_request.get_buffer()->tag();
}
#endif
void Api::log_state() const
{
- session->log_state();
+ session_singleton->log_state();
}
bool Api::snapshot_equal(const Snapshot* s1, const Snapshot* s2) const
void Api::s_close() const
{
- session->close();
-}
-
-void Api::restore_initial_state() const
-{
- session->restore_initial_state();
+ session_singleton->close();
}
void Api::execute(Transition& transition, smx_simcall_t simcall) const
{
/* FIXME: once all simcalls have observers, kill the simcall parameter and use mc_model_checker->simcall_to_string() */
transition.textual = request_to_string(simcall, transition.times_considered_);
- session->execute(transition);
+ session_singleton->execute(transition);
}
-#if SIMGRID_HAVE_MC
void Api::automaton_load(const char* file) const
{
MC_automaton_load(file);
}
-#endif
std::vector<int> Api::automaton_propositional_symbol_evaluate() const
{