-/* Copyright (c) 2008-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2008-2019. The SimGrid Team. All rights reserved. */
/* This program is free software; you can redistribute it and/or modify it
* under the terms of the license (GNU LGPL) which comes with this package. */
-#include <cstdint>
-
-#include <xbt/dynar.h>
-#include <xbt/dynar.hpp>
-#include <xbt/log.h>
-#include <xbt/sysdep.h>
-
-#include "src/mc/Transition.hpp"
-#include "src/mc/VisitedState.hpp"
#include "src/mc/checker/CommunicationDeterminismChecker.hpp"
+#include "src/kernel/activity/MailboxImpl.hpp"
+#include "src/mc/VisitedState.hpp"
#include "src/mc/mc_exit.hpp"
#include "src/mc/mc_private.hpp"
#include "src/mc/mc_record.hpp"
#include "src/mc/mc_state.hpp"
#include "src/mc/remote/Client.hpp"
+#if HAVE_SMPI
#include "smpi_request.hpp"
+#endif
+
+#include <cstdint>
using simgrid::mc::remote;
mc_model_checker->process().read(temp_comm, comm_addr);
simgrid::kernel::activity::CommImpl* comm = temp_comm.getBuffer();
- smx_actor_t src_proc = mc_model_checker->process().resolveActor(simgrid::mc::remote(comm->src_proc));
- smx_actor_t dst_proc = mc_model_checker->process().resolveActor(simgrid::mc::remote(comm->dst_proc));
- comm_pattern->src_proc = src_proc->pid;
- comm_pattern->dst_proc = dst_proc->pid;
+ smx_actor_t src_proc = mc_model_checker->process().resolveActor(simgrid::mc::remote(comm->src_actor_.get()));
+ smx_actor_t dst_proc = mc_model_checker->process().resolveActor(simgrid::mc::remote(comm->dst_actor_.get()));
+ comm_pattern->src_proc = src_proc->get_pid();
+ comm_pattern->dst_proc = dst_proc->get_pid();
comm_pattern->src_host = MC_smx_actor_get_host_name(src_proc);
comm_pattern->dst_host = MC_smx_actor_get_host_name(dst_proc);
- if (comm_pattern->data.size() == 0 && comm->src_buff != nullptr) {
+ if (comm_pattern->data.size() == 0 && comm->src_buff_ != nullptr) {
size_t buff_size;
- mc_model_checker->process().read(&buff_size, remote(comm->dst_buff_size));
+ mc_model_checker->process().read(&buff_size, remote(comm->dst_buff_size_));
comm_pattern->data.resize(buff_size);
mc_model_checker->process().read_bytes(comm_pattern->data.data(), comm_pattern->data.size(),
- remote(comm->src_buff));
+ remote(comm->src_buff_));
}
}
/********** Non Static functions ***********/
-void CommunicationDeterminismChecker::get_comm_pattern(xbt_dynar_t list, smx_simcall_t request,
- e_mc_call_type_t call_type, int backtracking)
+void CommunicationDeterminismChecker::get_comm_pattern(smx_simcall_t request, e_mc_call_type_t call_type,
+ int backtracking)
{
const smx_actor_t issuer = MC_smx_simcall_get_issuer(request);
simgrid::mc::PatternCommunicationList* initial_pattern =
- xbt_dynar_get_as(initial_communications_pattern, issuer->pid, simgrid::mc::PatternCommunicationList*);
- xbt_dynar_t incomplete_pattern = xbt_dynar_get_as(incomplete_communications_pattern, issuer->pid, xbt_dynar_t);
+ xbt_dynar_get_as(initial_communications_pattern, issuer->get_pid(), simgrid::mc::PatternCommunicationList*);
+ xbt_dynar_t incomplete_pattern = xbt_dynar_get_as(incomplete_communications_pattern, issuer->get_pid(), xbt_dynar_t);
std::unique_ptr<simgrid::mc::PatternCommunication> pattern =
std::unique_ptr<simgrid::mc::PatternCommunication>(new simgrid::mc::PatternCommunication());
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);
- pattern->src_proc = mc_model_checker->process().resolveActor(simgrid::mc::remote(synchro->src_proc))->pid;
+ 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_actor_.get()))->get_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));
+#if HAVE_SMPI
+ 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();
+#endif
- if (synchro->src_buff != nullptr) {
- pattern->data.resize(synchro->src_buff_size);
- mc_model_checker->process().read_bytes(pattern->data.data(), pattern->data.size(), remote(synchro->src_buff));
+ if (synchro->src_buff_ != nullptr) {
+ pattern->data.resize(synchro->src_buff_size_);
+ mc_model_checker->process().read_bytes(pattern->data.data(), pattern->data.size(), remote(synchro->src_buff_));
}
+#if HAVE_SMPI
if(mpi_request.detached()){
if (not this->initial_communications_pattern_done) {
/* Store comm pattern */
}
return;
}
+#endif
} else if (call_type == MC_CALL_TYPE_RECV) {
pattern->type = simgrid::mc::PatternCommunicationType::receive;
pattern->comm_addr = static_cast<simgrid::kernel::activity::CommImpl*>(simcall_comm_irecv__getraw__result(request));
+#if HAVE_SMPI
simgrid::smpi::Request mpi_request;
mc_model_checker->process().read(&mpi_request,
remote((simgrid::smpi::Request*)simcall_comm_irecv__get__data(request)));
pattern->tag = mpi_request.tag();
+#endif
simgrid::mc::Remote<simgrid::kernel::activity::CommImpl> temp_comm;
mc_model_checker->process().read(temp_comm,
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(remote_name);
- pattern->dst_proc = mc_model_checker->process().resolveActor(simgrid::mc::remote(comm->dst_proc))->pid;
+ 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_actor_.get()))->get_pid();
pattern->dst_host = MC_smx_actor_get_host_name(issuer);
} else
xbt_die("Unexpected call_type %i", (int) call_type);
- XBT_DEBUG("Insert incomplete comm pattern %p for process %lu", pattern.get(), issuer->pid);
- xbt_dynar_t dynar = xbt_dynar_get_as(incomplete_communications_pattern, issuer->pid, xbt_dynar_t);
+ XBT_DEBUG("Insert incomplete comm pattern %p for process %ld", pattern.get(), issuer->get_pid());
+ xbt_dynar_t dynar = xbt_dynar_get_as(incomplete_communications_pattern, issuer->get_pid(), xbt_dynar_t);
simgrid::mc::PatternCommunication* pattern2 = pattern.release();
xbt_dynar_push(dynar, &pattern2);
}
void CommunicationDeterminismChecker::complete_comm_pattern(
- xbt_dynar_t list, simgrid::mc::RemotePtr<simgrid::kernel::activity::CommImpl> comm_addr, unsigned int issuer,
- int backtracking)
+ simgrid::mc::RemotePtr<simgrid::kernel::activity::CommImpl> comm_addr, unsigned int issuer, int backtracking)
{
simgrid::mc::PatternCommunication* current_comm_pattern;
unsigned int cursor = 0;
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 ****");
/* TODO : handle test and testany simcalls */
e_mc_call_type_t call = MC_get_call_type(req);
mc_model_checker->handle_simcall(state->transition);
- MC_handle_comm_pattern(call, req, req_num, nullptr, 1);
+ MC_handle_comm_pattern(call, req, req_num, 1);
mc_model_checker->wait_for_requests();
/* Update statistics */
}
}
-void CommunicationDeterminismChecker::main()
+void CommunicationDeterminismChecker::real_run()
{
std::unique_ptr<simgrid::mc::VisitedState> visited_state = nullptr;
smx_simcall_t req = nullptr;
mc_model_checker->handle_simcall(state->transition);
/* After this call req is no longer useful */
- if (not this->initial_communications_pattern_done)
- MC_handle_comm_pattern(call, req, req_num, initial_communications_pattern, 0);
- else
- MC_handle_comm_pattern(call, req, req_num, nullptr, 0);
+ MC_handle_comm_pattern(call, req, req_num, 0);
/* Wait for requests (schedules processes) */
mc_model_checker->wait_for_requests();
this->prepare();
- this->main();
+ this->real_run();
}
Checker* createCommunicationDeterminismChecker(Session& session)
