#include "src/mc/Transition.hpp"
#include "src/mc/VisitedState.hpp"
#include "src/mc/checker/CommunicationDeterminismChecker.hpp"
-#include "src/mc/mc_exit.h"
-#include "src/mc/mc_private.h"
-#include "src/mc/mc_record.h"
-#include "src/mc/mc_request.h"
-#include "src/mc/mc_smx.h"
-#include "src/mc/mc_state.h"
+#include "src/mc/mc_exit.hpp"
+#include "src/mc/mc_private.hpp"
+#include "src/mc/mc_record.hpp"
+#include "src/mc/mc_request.hpp"
+#include "src/mc/mc_smx.hpp"
+#include "src/mc/mc_state.hpp"
#include "src/mc/remote/Client.hpp"
-#include "src/smpi/smpi_request.hpp"
+#include "smpi_request.hpp"
using simgrid::mc::remote;
switch(diff) {
case TYPE_DIFF:
- res = bprintf("%s Different type for communication #%d", type, cursor);
+ res = bprintf("%s Different type for communication #%u", type, cursor);
break;
case RDV_DIFF:
- res = bprintf("%s Different rdv for communication #%d", type, cursor);
+ res = bprintf("%s Different rdv for communication #%u", type, cursor);
break;
case TAG_DIFF:
- res = bprintf("%s Different tag for communication #%d", type, cursor);
+ res = bprintf("%s Different tag for communication #%u", type, cursor);
break;
case SRC_PROC_DIFF:
- res = bprintf("%s Different source for communication #%d", type, cursor);
+ res = bprintf("%s Different source for communication #%u", type, cursor);
break;
case DST_PROC_DIFF:
- res = bprintf("%s Different destination for communication #%d", type, cursor);
+ res = bprintf("%s Different destination for communication #%u", type, cursor);
break;
case DATA_SIZE_DIFF:
- res = bprintf("%s\n Different data size for communication #%d", type, cursor);
+ res = bprintf("%s\n Different data size for communication #%u", type, cursor);
break;
case DATA_DIFF:
- res = bprintf("%s\n Different data for communication #%d", type, cursor);
+ res = bprintf("%s\n Different data for communication #%u", type, cursor);
break;
default:
res = nullptr;
if (call_type == MC_CALL_TYPE_SEND) {
/* Create comm pattern */
pattern->type = simgrid::mc::PatternCommunicationType::send;
- pattern->comm_addr = simcall_comm_isend__get__result(request);
+ pattern->comm_addr = static_cast<simgrid::kernel::activity::CommImpl*>(simcall_comm_isend__getraw__result(request));
simgrid::mc::Remote<simgrid::kernel::activity::CommImpl> temp_synchro;
mc_model_checker->process().read(temp_synchro,
static_cast<simgrid::kernel::activity::CommImpl*>(temp_synchro.getBuffer());
char* remote_name = mc_model_checker->process().read<char*>(
- (std::uint64_t)(synchro->mbox ? &synchro->mbox->name_ : &synchro->mbox_cpy->name_));
- pattern->rdv = mc_model_checker->process().read_string(remote_name);
+ RemotePtr<char*>((uint64_t)(synchro->mbox ? &synchro->mbox->name_ : &synchro->mbox_cpy->name_)));
+ pattern->rdv = mc_model_checker->process().read_string(RemotePtr<char>(remote_name));
pattern->src_proc = mc_model_checker->process().resolveActor(simgrid::mc::remote(synchro->src_proc))->pid;
pattern->src_host = MC_smx_actor_get_host_name(issuer);
- simgrid::smpi::Request mpi_request =
- mc_model_checker->process().read<simgrid::smpi::Request>((std::uint64_t)simcall_comm_isend__get__data(request));
+ simgrid::smpi::Request mpi_request = mc_model_checker->process().read<simgrid::smpi::Request>(
+ RemotePtr<simgrid::smpi::Request>((std::uint64_t)simcall_comm_isend__get__data(request)));
pattern->tag = mpi_request.tag();
if (synchro->src_buff != nullptr) {
}
} else if (call_type == MC_CALL_TYPE_RECV) {
pattern->type = simgrid::mc::PatternCommunicationType::receive;
- pattern->comm_addr = simcall_comm_irecv__get__result(request);
+ pattern->comm_addr = static_cast<simgrid::kernel::activity::CommImpl*>(simcall_comm_irecv__getraw__result(request));
simgrid::smpi::Request mpi_request;
mc_model_checker->process().read(&mpi_request,
simgrid::kernel::activity::CommImpl* comm = temp_comm.getBuffer();
char* remote_name;
- mc_model_checker->process().read(&remote_name, remote(comm->mbox ? &comm->mbox->name_ : &comm->mbox_cpy->name_));
- pattern->rdv = mc_model_checker->process().read_string(remote_name);
+ mc_model_checker->process().read(
+ &remote_name, remote(comm->mbox ? &simgrid::xbt::string::to_string_data(comm->mbox->name_).data
+ : &simgrid::xbt::string::to_string_data(comm->mbox_cpy->name_).data));
+ pattern->rdv = mc_model_checker->process().read_string(RemotePtr<char>(remote_name));
pattern->dst_proc = mc_model_checker->process().resolveActor(simgrid::mc::remote(comm->dst_proc))->pid;
pattern->dst_host = MC_smx_actor_get_host_name(issuer);
} else
void CommunicationDeterminismChecker::logState() // override
{
- Checker::logState();
if (_sg_mc_comms_determinism && not this->recv_deterministic && this->send_deterministic) {
XBT_INFO("******************************************************");
XBT_INFO("**** Only-send-deterministic communication pattern ****");
/* Get an enabled actor and insert it in the interleave set of the initial state */
for (auto& actor : mc_model_checker->process().actors())
if (simgrid::mc::actor_is_enabled(actor.copy.getBuffer()))
- initial_state->interleave(actor.copy.getBuffer());
+ initial_state->addInterleavingSet(actor.copy.getBuffer());
stack_.push_back(std::move(initial_state));
}
/* Restore the initial state */
simgrid::mc::session->restoreInitialState();
- // int n = xbt_dynar_length(incomplete_communications_pattern);
unsigned n = MC_smx_get_maxpid();
assert(n == xbt_dynar_length(incomplete_communications_pattern));
assert(n == xbt_dynar_length(initial_communications_pattern));
simgrid::mc::State* state = stack_.back().get();
XBT_DEBUG("**************************************************");
- XBT_DEBUG("Exploration depth = %zi (state = %d, interleaved processes = %zd)", stack_.size(), state->num,
+ XBT_DEBUG("Exploration depth = %zu (state = %d, interleaved processes = %zu)", stack_.size(), state->num,
state->interleaveSize());
/* Update statistics */
mc_model_checker->visited_states++;
- if (stack_.size() <= (std::size_t)_sg_mc_max_depth && (req = MC_state_get_request(state)) != nullptr &&
- (visited_state == nullptr)) {
+ if (stack_.size() <= (std::size_t)_sg_mc_max_depth)
+ req = MC_state_get_request(state);
+ else
+ req = nullptr;
+
+ if (req != nullptr && visited_state == nullptr) {
int req_num = state->transition.argument;
* with the initial pattern. */
bool compare_snapshots = all_communications_are_finished() && this->initial_communications_pattern_done;
- if (_sg_mc_max_visited_states == 0 ||
- (visited_state = visitedStates_.addVisitedState(expandedStatesCount_, next_state.get(), compare_snapshots)) ==
- nullptr) {
+ if (_sg_mc_max_visited_states != 0)
+ visited_state = visitedStates_.addVisitedState(expandedStatesCount_, next_state.get(), compare_snapshots);
+ else
+ visited_state = nullptr;
+
+ if (visited_state == nullptr) {
/* Get enabled actors and insert them in the interleave set of the next state */
for (auto& actor : mc_model_checker->process().actors())
if (simgrid::mc::actor_is_enabled(actor.copy.getBuffer()))
- next_state->interleave(actor.copy.getBuffer());
+ next_state->addInterleavingSet(actor.copy.getBuffer());
if (dot_output != nullptr)
fprintf(dot_output, "\"%d\" -> \"%d\" [%s];\n",
XBT_DEBUG("State already visited (equal to state %d), exploration stopped on this path.",
visited_state->original_num == -1 ? visited_state->num : visited_state->original_num);
else
- XBT_DEBUG("There are no more processes to interleave. (depth %zi)", stack_.size());
+ XBT_DEBUG("There are no more processes to interleave. (depth %zu)", stack_.size());
if (not this->initial_communications_pattern_done)
this->initial_communications_pattern_done = 1;
/* Trash the current state, no longer needed */
- XBT_DEBUG("Delete state %d at depth %zi", state->num, stack_.size());
+ XBT_DEBUG("Delete state %d at depth %zu", state->num, stack_.size());
stack_.pop_back();
visited_state = nullptr;
/* Check for deadlocks */
if (mc_model_checker->checkDeadlock()) {
MC_show_deadlock();
- throw new simgrid::mc::DeadlockError();
+ throw simgrid::mc::DeadlockError();
}
while (not stack_.empty()) {
stack_.pop_back();
if (state->interleaveSize() && stack_.size() < (std::size_t)_sg_mc_max_depth) {
/* We found a back-tracking point, let's loop */
- XBT_DEBUG("Back-tracking to state %d at depth %zi", state->num, stack_.size() + 1);
+ XBT_DEBUG("Back-tracking to state %d at depth %zu", state->num, stack_.size() + 1);
stack_.push_back(std::move(state));
this->restoreState();
- XBT_DEBUG("Back-tracking to state %d at depth %zi done", stack_.back()->num, stack_.size());
+ XBT_DEBUG("Back-tracking to state %d at depth %zu done", stack_.back()->num, stack_.size());
break;
} else {
- XBT_DEBUG("Delete state %d at depth %zi", state->num, stack_.size() + 1);
+ XBT_DEBUG("Delete state %d at depth %zu", state->num, stack_.size() + 1);
}
}
}
