-/* Copyright (c) 2010-2021. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2010-2022. 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 "smpi_comm.hpp"
+#include "simgrid/host.h"
#include "smpi_coll.hpp"
#include "smpi_datatype.hpp"
+#include "smpi_info.hpp"
#include "smpi_request.hpp"
#include "smpi_win.hpp"
-#include "smpi_info.hpp"
#include "src/smpi/include/smpi_actor.hpp"
#include "src/surf/HostImpl.hpp"
/* Support for cartesian topology was added, but there are 2 other types of topology, graph et dist graph. In order to
* support them, we have to add a field SMPI_Topo_type, and replace the MPI_Topology field by an union. */
-namespace simgrid{
-namespace smpi{
+namespace simgrid::smpi {
std::unordered_map<int, smpi_key_elem> Comm::keyvals_;
int Comm::keyval_id_=0;
colls::bcast(&id, 1, MPI_INT, 0, this);
XBT_DEBUG("Communicator %p has id %d", this, id);
id_=id;//only set here, as we don't want to change it in the middle of the bcast
- colls::barrier(this);
}
}
auto* cp = new Group(this->group());
(*newcomm) = new Comm(cp, this->topo());
- for (auto const& it : attributes()) {
- auto elem_it = keyvals_.find(it.first);
- xbt_assert(elem_it != keyvals_.end(), "Keyval not found for Comm: %d", it.first);
+ for (auto const& [key, value] : attributes()) {
+ auto elem_it = keyvals_.find(key);
+ xbt_assert(elem_it != keyvals_.end(), "Keyval not found for Comm: %d", key);
smpi_key_elem& elem = elem_it->second;
int ret = MPI_SUCCESS;
int flag = 0;
void* value_out = nullptr;
if (elem.copy_fn.comm_copy_fn == MPI_COMM_DUP_FN) {
- value_out = it.second;
+ value_out = value;
flag = 1;
} else if (elem.copy_fn.comm_copy_fn != MPI_NULL_COPY_FN) {
- ret = elem.copy_fn.comm_copy_fn(this, it.first, elem.extra_state, it.second, &value_out, &flag);
+ ret = elem.copy_fn.comm_copy_fn(this, key, elem.extra_state, value, &value_out, &flag);
}
if (elem.copy_fn.comm_copy_fn_fort != MPI_NULL_COPY_FN) {
value_out = xbt_new(int, 1);
if (*(int*)*elem.copy_fn.comm_copy_fn_fort == 1) { // MPI_COMM_DUP_FN
- memcpy(value_out, it.second, sizeof(int));
+ memcpy(value_out, value, sizeof(int));
flag = 1;
} else { // not null, nor dup
- elem.copy_fn.comm_copy_fn_fort(this, it.first, elem.extra_state, it.second, value_out, &flag, &ret);
+ elem.copy_fn.comm_copy_fn_fort(this, key, elem.extra_state, value, value_out, &flag, &ret);
}
if (ret != MPI_SUCCESS)
xbt_free(value_out);
}
if (flag) {
elem.refcount++;
- (*newcomm)->attributes().emplace(it.first, value_out);
+ (*newcomm)->attributes().try_emplace(key, value_out);
}
}
//duplicate info if present
std::array<char, MPI_MAX_NAME_STRING + 1> name;
this->get_name(name.data(), &size);
if (name[0]=='\0')
- return std::string("MPI_Comm");
+ return "MPI_Comm";
else
- return std::string(name.data());
+ return name.data();
}
{
if (this == MPI_COMM_UNINITIALIZED)
return smpi_process()->comm_world()->is_uniform();
- return is_uniform_ != 0;
+ return is_uniform_;
}
bool Comm::is_blocked() const
{
if (this == MPI_COMM_UNINITIALIZED)
return smpi_process()->comm_world()->is_blocked();
- return is_blocked_ != 0;
+ return is_blocked_;
}
bool Comm::is_smp_comm() const
}
std::vector<MPI_Request> requests(rankmap.size());
int reqs = 0;
- for (auto const& rank : rankmap) {
- if (rank.second != 0) {
+ for (auto const& [_, rank] : rankmap) {
+ if (rank != 0) {
group_snd[reqs]=new Group(group_out);
- requests[reqs] = Request::isend(&(group_snd[reqs]), 1, MPI_PTR, rank.second, system_tag, this);
+ requests[reqs] = Request::isend(&(group_snd[reqs]), 1, MPI_PTR, rank, system_tag, this);
reqs++;
}
}
simgrid::smpi::Info::unref(comm->info_);
if(comm->errhandlers_!=nullptr){
for (int i=0; i<comm->size(); i++)
- if (comm->errhandlers_[i]!=MPI_ERRHANDLER_NULL)
+ if (comm->errhandlers_[i]!=MPI_ERRHANDLER_NULL)
simgrid::smpi::Errhandler::unref(comm->errhandlers_[i]);
delete[] comm->errhandlers_;
} else if (comm->errhandler_ != MPI_ERRHANDLER_NULL)
// Are the nodes uniform ? = same number of process/node
int my_local_size=comm_intra->size();
+ int is_uniform;
if(comm_intra->rank()==0) {
- int is_uniform = 1;
+ is_uniform = 1;
auto* non_uniform_map = xbt_new0(int, leader_group_size);
allgather__ring(&my_local_size, 1, MPI_INT,
non_uniform_map, 1, MPI_INT, leader_comm);
}else{
xbt_free(non_uniform_map);
}
- is_uniform_=is_uniform;
}
- bcast__scatter_LR_allgather(&is_uniform_, 1, MPI_INT, 0, comm_intra);
+ bcast__scatter_LR_allgather(&is_uniform, 1, MPI_INT, 0, comm_intra);
+ is_uniform_ = (is_uniform != 0);
// we need to switch as the called function may silently touch global variables
smpi_switch_data_segment(s4u::Actor::self());
int global_blocked;
allreduce__default(&is_blocked, &global_blocked, 1, MPI_INT, MPI_LAND, this);
- if(MPI_COMM_WORLD==MPI_COMM_UNINITIALIZED || this==MPI_COMM_WORLD){
- if(this->rank()==0){
- is_blocked_ = global_blocked;
- }
- }else{
- is_blocked_=global_blocked;
- }
+ if ((MPI_COMM_WORLD != MPI_COMM_UNINITIALIZED && this != MPI_COMM_WORLD) || this->rank() == 0)
+ is_blocked_ = (global_blocked != 0);
delete[] leader_list;
if(replaying)
}
}
-} // namespace smpi
-} // namespace simgrid
+static inline std::string hash_message(int src, int dst, int tag){
+ return std::to_string(tag) + '_' + std::to_string(src) + '_' + std::to_string(dst);
+}
+
+unsigned int Comm::get_sent_messages_count(int src, int dst, int tag)
+{
+ return sent_messages_[hash_message(src, dst, tag)];
+}
+
+void Comm::increment_sent_messages_count(int src, int dst, int tag)
+{
+ sent_messages_[hash_message(src, dst, tag)]++;
+}
+
+unsigned int Comm::get_received_messages_count(int src, int dst, int tag)
+{
+ return recv_messages_[hash_message(src, dst, tag)];
+}
+
+void Comm::increment_received_messages_count(int src, int dst, int tag)
+{
+ recv_messages_[hash_message(src, dst, tag)]++;
+}
+
+unsigned int Comm::get_collectives_count()
+{
+ if (this==MPI_COMM_UNINITIALIZED){
+ return smpi_process()->comm_world()->get_collectives_count();
+ }else if(this == MPI_COMM_WORLD || this == smpi_process()->comm_world()){
+ if (collectives_counts_.empty())
+ collectives_counts_.resize(this->size());
+ return collectives_counts_[this->rank()];
+ }else{
+ return collectives_count_;
+ }
+}
+
+void Comm::increment_collectives_count()
+{
+ if (this==MPI_COMM_UNINITIALIZED){
+ smpi_process()->comm_world()->increment_collectives_count();
+ }else if (this == MPI_COMM_WORLD || this == smpi_process()->comm_world()){
+ if (collectives_counts_.empty())
+ collectives_counts_.resize(this->size());
+ collectives_counts_[this->rank()]++;
+ }else{
+ collectives_count_++;
+ }
+}
+
+} // namespace simgrid::smpi
