-/* Copyright (c) 2009-2022. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2009-2023. 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. */
}
// Recursive template code derived from Matthieu M.
-template <class Tuple, size_t Index = std::tuple_size<Tuple>::value - 1> class HashValueImpl {
+template <class Tuple, size_t Index = std::tuple_size_v<Tuple> - 1> class HashValueImpl {
public:
static void apply(size_t& seed, Tuple const& tuple)
{
return i < action.size() ? simgrid::smpi::Datatype::decode(action[i]) : simgrid::smpi::replay::MPI_DEFAULT_TYPE;
}
-namespace simgrid {
-namespace smpi {
-
-namespace replay {
+namespace simgrid::smpi::replay {
MPI_Datatype MPI_DEFAULT_TYPE;
class RequestStorage {
{
for (auto const& [_, reqs] : store) {
aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
- for (auto& req: reqs){
+ for (const auto& req : reqs) {
if (req != MPI_REQUEST_NULL && (req->src() == my_proc_id || req->dst() == my_proc_id)) {
vec.push_back(req);
req->print_request("MM");
tag = std::stoi(action[4]);
}
-void SendRecvParser::parse(simgrid::xbt::ReplayAction& action, const std::string&)
+void SendOrRecvParser::parse(simgrid::xbt::ReplayAction& action, const std::string&)
{
CHECK_ACTION_PARAMS(action, 3, 1)
partner = std::stoi(action[2]);
tag = std::stoi(action[3]);
- size = parse_integer<size_t>(action[4]);
+ size = parse_integer<ssize_t>(action[4]);
datatype1 = parse_datatype(action, 5);
}
void LocationParser::parse(simgrid::xbt::ReplayAction& action, const std::string&)
{
CHECK_ACTION_PARAMS(action, 2, 0)
- filename = std::string(action[2]);
+ filename = action[2];
line = std::stoi(action[3]);
}
+void SendRecvParser::parse(simgrid::xbt::ReplayAction& action, const std::string&)
+{
+ CHECK_ACTION_PARAMS(action, 6, 0)
+ sendcount = parse_integer<int>(action[2]);
+ dst = std::stoi(action[3]);
+ recvcount = parse_integer<int>(action[4]);
+ src = std::stoi(action[5]);
+ datatype1 = parse_datatype(action, 6);
+ datatype2 = parse_datatype(action, 7);
+}
+
void BcastArgParser::parse(simgrid::xbt::ReplayAction& action, const std::string&)
{
CHECK_ACTION_PARAMS(action, 1, 2)
void SendAction::kernel(simgrid::xbt::ReplayAction&)
{
- const SendRecvParser& args = get_args();
+ const SendOrRecvParser& args = get_args();
aid_t dst_traced = MPI_COMM_WORLD->group()->actor(args.partner);
TRACE_smpi_comm_in(
void RecvAction::kernel(simgrid::xbt::ReplayAction&)
{
- const SendRecvParser& args = get_args();
+ const SendOrRecvParser& args = get_args();
TRACE_smpi_comm_in(
get_pid(), __func__,
new simgrid::instr::Pt2PtTIData(get_name(), args.partner, args.size, args.tag, Datatype::encode(args.datatype1)));
MPI_Status status;
// unknown size from the receiver point of view
- size_t arg_size = args.size;
- if (arg_size == 0) {
+ ssize_t arg_size = args.size;
+ if (arg_size < 0) {
Request::probe(args.partner, args.tag, MPI_COMM_WORLD, &status);
arg_size = status.count;
}
}
}
+void SendRecvAction::kernel(simgrid::xbt::ReplayAction&)
+{
+ XBT_DEBUG("Enters SendRecv");
+ const SendRecvParser& args = get_args();
+ aid_t my_proc_id = simgrid::s4u::this_actor::get_pid();
+ aid_t src_traced = MPI_COMM_WORLD->group()->actor(args.src);
+ aid_t dst_traced = MPI_COMM_WORLD->group()->actor(args.dst);
+
+ MPI_Status status;
+ int sendtag=0;
+ int recvtag=0;
+
+ // FIXME: Hack the way to trace this one
+ auto dst_hack = std::make_shared<std::vector<int>>();
+ auto src_hack = std::make_shared<std::vector<int>>();
+ dst_hack->push_back(dst_traced);
+ src_hack->push_back(src_traced);
+ TRACE_smpi_comm_in(my_proc_id, __func__,
+ new simgrid::instr::VarCollTIData(
+ "sendRecv", -1, args.sendcount,
+ dst_hack, args.recvcount, src_hack,
+ simgrid::smpi::Datatype::encode(args.datatype1), simgrid::smpi::Datatype::encode(args.datatype2)));
+
+ TRACE_smpi_send(my_proc_id, my_proc_id, dst_traced, sendtag, args.sendcount * args.datatype1->size());
+
+ simgrid::smpi::Request::sendrecv(nullptr, args.sendcount, args.datatype1, args.dst, sendtag, nullptr, args.recvcount, args.datatype2, args.src,
+ recvtag, MPI_COMM_WORLD, &status);
+
+ TRACE_smpi_recv(src_traced, my_proc_id, recvtag);
+ TRACE_smpi_comm_out(my_proc_id);
+ XBT_DEBUG("Exits SendRecv");
+}
+
void ComputeAction::kernel(simgrid::xbt::ReplayAction&)
{
const ComputeParser& args = get_args();
void LocationAction::kernel(simgrid::xbt::ReplayAction&)
{
const LocationParser& args = get_args();
- smpi_trace_set_call_location(args.filename.c_str(), args.line);
+ smpi_trace_set_call_location(args.filename.c_str(), args.line, "");
}
void TestAction::kernel(simgrid::xbt::ReplayAction&)
TRACE_smpi_comm_out(get_pid());
}
-} // Replay Namespace
-}} // namespace simgrid::smpi
+} // namespace simgrid::smpi::replay
static std::unordered_map<aid_t, simgrid::smpi::replay::RequestStorage> storage;
/** @brief Only initialize the replay, don't do it for real */
xbt_replay_action_register("recv", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::replay::RecvAction("recv", storage[simgrid::s4u::this_actor::get_pid()]).execute(action); });
xbt_replay_action_register("irecv", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::replay::RecvAction("irecv", storage[simgrid::s4u::this_actor::get_pid()]).execute(action); });
xbt_replay_action_register("test", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::replay::TestAction(storage[simgrid::s4u::this_actor::get_pid()]).execute(action); });
+ xbt_replay_action_register("sendRecv", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::replay::SendRecvAction().execute(action); });
xbt_replay_action_register("wait", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::replay::WaitAction(storage[simgrid::s4u::this_actor::get_pid()]).execute(action); });
xbt_replay_action_register("waitall", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::replay::WaitAllAction(storage[simgrid::s4u::this_actor::get_pid()]).execute(action); });
xbt_replay_action_register("barrier", [](simgrid::xbt::ReplayAction& action) { simgrid::smpi::replay::BarrierAction().execute(action); });
unsigned int i=0;
for (auto const& [_, reqs] : storage[simgrid::s4u::this_actor::get_pid()].get_store()) {
- for (auto& req : reqs) {
+ for (const auto& req : reqs) {
requests[i] = req; // FIXME: overwritten at each iteration?
}
i++;
simgrid::smpi::Request::waitall(count_requests, requests.data(), MPI_STATUSES_IGNORE);
}
- if(simgrid::config::get_value<bool>("smpi/finalization-barrier"))
+ if (simgrid::config::get_value<bool>("smpi/barrier-finalization"))
simgrid::smpi::colls::barrier(MPI_COMM_WORLD);
active_processes--;