XBT_PRIVATE void smpi_deployment_register_process(const std::string& instance_id, int rank,
const simgrid::s4u::Actor* actor);
+XBT_PRIVATE void smpi_deployment_startup_barrier(const std::string& instance_id);
XBT_PRIVATE void smpi_deployment_unregister_process(const std::string& instance_id);
XBT_PRIVATE MPI_Comm* smpi_deployment_comm_world(const std::string& instance_id);
void mark_as_initialized();
void set_replaying(bool value);
bool replaying() const;
+ std::string get_instance_id() const { return instance_id_;}
void set_tracing_category(const std::string& category) { tracing_category_ = category; }
const std::string& get_tracing_category() const { return tracing_category_; }
smpi_trace_call_location_t* call_location();
#include "smpi_host.hpp"
#include "private.hpp"
#include "simgrid/s4u/Engine.hpp"
+#include "simgrid/s4u/Barrier.hpp"
#include "smpi_comm.hpp"
#include <map>
auto* group = new simgrid::smpi::Group(size_);
comm_world_ = new simgrid::smpi::Comm(group, nullptr, false, -1);
universe_size += max_no_processes;
+ bar_ = new s4u::Barrier(size_);
}
-
+ s4u::Barrier* bar_;
unsigned int size_;
unsigned int finalized_ranks_ = 0;
MPI_Comm comm_world_;
{
const Instance& instance = smpi_instances.at(instance_id);
instance.comm_world_->group()->set_mapping(actor->get_pid(), rank);
+
+}
+
+void smpi_deployment_startup_barrier(const std::string& instance_id)
+{
+ const Instance& instance = smpi_instances.at(instance_id);
+ instance.bar_->wait();
}
void smpi_deployment_unregister_process(const std::string& instance_id)
if (instance.finalized_ranks_ == instance.size_) {
simgrid::smpi::Comm::destroy(instance.comm_world_);
+ delete instance.bar_;
smpi_instances.erase(instance_id);
}
}
smpi_init_fortran_types();
if(_smpi_init_sleep > 0)
simgrid::s4u::this_actor::sleep_for(_smpi_init_sleep);
+ smpi_deployment_startup_barrier(smpi_process()->get_instance_id());
}
void SMPI_thread_create() {