--- /dev/null
+/* Public interface to the Link datatype */
+
+/* Copyright (c) 2018. 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. */
+
+#ifndef INCLUDE_SIMGRID_BARRIER_H_
+#define INCLUDE_SIMGRID_BARRIER_H_
+
+#include <simgrid/forward.h>
+
+/* C interface */
+SG_BEGIN_DECL()
+
+XBT_PUBLIC sg_bar_t sg_barrier_init(unsigned int count);
+XBT_PUBLIC void sg_barrier_destroy(sg_bar_t bar);
+XBT_PUBLIC int sg_barrier_wait(sg_bar_t bar);
+
+SG_END_DECL()
+
+#endif /* INCLUDE_SIMGRID_BARRIER_H_ */
using ActorPtr = boost::intrusive_ptr<Actor>;
XBT_PUBLIC void intrusive_ptr_release(Actor* actor);
XBT_PUBLIC void intrusive_ptr_add_ref(Actor* actor);
+class Barrier;
class Comm;
using CommPtr = boost::intrusive_ptr<Comm>;
XBT_PUBLIC void intrusive_ptr_release(Comm* c);
} // namespace simgrid
typedef simgrid::s4u::Actor s4u_Actor;
+typedef simgrid::s4u::Barrier s4u_Barrier;
typedef simgrid::s4u::Host s4u_Host;
typedef simgrid::s4u::Link s4u_Link;
typedef simgrid::s4u::File s4u_File;
#else
typedef struct s4u_Actor s4u_Actor;
+typedef struct s4u_Barrier s4u_Barrier;
typedef struct s4u_Host s4u_Host;
typedef struct s4u_Link s4u_Link;
typedef struct s4u_File s4u_File;
#endif
+typedef s4u_Barrier* sg_bar_t;
typedef s4u_NetZone* sg_netzone_t;
typedef s4u_Host* sg_host_t;
typedef s4u_Link* sg_link_t;
#define SIMGRID_MSG_H
#include <simgrid/actor.h>
+#include <simgrid/barrier.h>
#include <simgrid/engine.h>
#include <simgrid/forward.h>
#include <simgrid/host.h>
XBT_PUBLIC void MSG_sem_destroy(msg_sem_t sem);
XBT_PUBLIC int MSG_sem_would_block(msg_sem_t sem);
-/** @brief Opaque type representing a barrier identifier
- * @ingroup msg_synchro
- * @hideinitializer
- */
-
-#define MSG_BARRIER_SERIAL_PROCESS -1
-typedef struct s_msg_bar_t* msg_bar_t;
+typedef sg_bar_t msg_bar_t;
XBT_PUBLIC msg_bar_t MSG_barrier_init(unsigned int count);
XBT_PUBLIC void MSG_barrier_destroy(msg_bar_t bar);
XBT_PUBLIC int MSG_barrier_wait(msg_bar_t bar);
{
sg_vm_destroy(vm);
}
+/********* barriers ************/
+sg_bar_t MSG_barrier_init(unsigned int count)
+{
+ return sg_barrier_init(count);
+}
+
+void MSG_barrier_destroy(sg_bar_t bar)
+{
+ sg_barrier_destroy(bar);
+}
+
+int MSG_barrier_wait(sg_bar_t bar)
+{
+ return sg_barrier_wait(bar);
+}
return simgrid::simix::simcall([sem] { return SIMIX_sem_would_block(sem); });
}
-/*-**** barrier related functions ****-*/
-struct s_msg_bar_t {
- xbt_mutex_t mutex;
- xbt_cond_t cond;
- unsigned int arrived_processes;
- unsigned int expected_processes;
-};
-
-/** @brief Initializes a barrier, with count elements */
-msg_bar_t MSG_barrier_init(unsigned int count) {
- msg_bar_t bar = new s_msg_bar_t;
- bar->expected_processes = count;
- bar->arrived_processes = 0;
- bar->mutex = xbt_mutex_init();
- bar->cond = xbt_cond_init();
- return bar;
-}
-
-/** @brief Initializes a barrier, with count elements */
-void MSG_barrier_destroy(msg_bar_t bar) {
- xbt_mutex_destroy(bar->mutex);
- xbt_cond_destroy(bar->cond);
- delete bar;
-}
-
-/** @brief Performs a barrier already initialized */
-int MSG_barrier_wait(msg_bar_t bar) {
- xbt_mutex_acquire(bar->mutex);
- bar->arrived_processes++;
- XBT_DEBUG("waiting %p %u/%u", bar, bar->arrived_processes, bar->expected_processes);
- if (bar->arrived_processes == bar->expected_processes) {
- xbt_cond_broadcast(bar->cond);
- xbt_mutex_release(bar->mutex);
- bar->arrived_processes = 0;
- return MSG_BARRIER_SERIAL_PROCESS;
- }
-
- xbt_cond_wait(bar->cond, bar->mutex);
- xbt_mutex_release(bar->mutex);
- return 0;
-}
/**@}*/
#include <xbt/ex.hpp>
#include <xbt/log.hpp>
+#include "simgrid/barrier.h"
#include "simgrid/s4u/Barrier.hpp"
#include "simgrid/simix.h"
}
} // namespace s4u
} // namespace simgrid
+
+/* **************************** Public C interface *************************** */
+
+sg_bar_t sg_barrier_init(unsigned int count)
+{
+ return new simgrid::s4u::Barrier(count);
+}
+
+/** @brief Initializes a barrier, with count elements */
+void sg_barrier_destroy(sg_bar_t bar)
+{
+ delete bar;
+}
+
+/** @brief Performs a barrier already initialized */
+int sg_barrier_wait(sg_bar_t bar)
+{
+ return bar->wait();
+}
#ifndef SMPI_PRIVATE_HPP
#define SMPI_PRIVATE_HPP
-#include "simgrid/msg.h" // msg_bar_t
+#include "simgrid/s4u/Barrier.hpp"
#include "smpi/smpi.h"
#include "smpi/smpi_helpers_internal.h"
#include "src/instr/instr_smpi.hpp"
XBT_PRIVATE void smpi_deployment_register_process(const std::string instance_id, int rank,
simgrid::s4u::ActorPtr actor);
XBT_PRIVATE MPI_Comm* smpi_deployment_comm_world(const std::string instance_id);
-XBT_PRIVATE msg_bar_t smpi_deployment_finalization_barrier(const std::string instance_id);
+XBT_PRIVATE simgrid::s4u::Barrier* smpi_deployment_finalization_barrier(const std::string instance_id);
XBT_PRIVATE void smpi_deployment_cleanup_instances();
XBT_PRIVATE void smpi_comm_copy_buffer_callback(smx_activity_t comm, void* buff, size_t buff_size);
int sampling_ = 0; /* inside an SMPI_SAMPLE_ block? */
std::string instance_id_;
bool replaying_ = false; /* is the process replaying a trace */
- msg_bar_t finalization_barrier_;
+ simgrid::s4u::Barrier* finalization_barrier_;
smpi_trace_call_location_t trace_call_loc_;
simgrid::s4u::ActorPtr actor_ = nullptr;
smpi_privatization_region_t privatized_region_;
papi_counter_t papi_counter_data_;
#endif
public:
- explicit Process(simgrid::s4u::ActorPtr actor, msg_bar_t barrier);
+ explicit Process(simgrid::s4u::ActorPtr actor, simgrid::s4u::Barrier* barrier);
~Process();
void set_data(int* argc, char*** argv);
void finalize();
#ifndef SMPI_WIN_HPP_INCLUDED
#define SMPI_WIN_HPP_INCLUDED
+#include "simgrid/s4u/Barrier.hpp"
#include "smpi_f2c.hpp"
#include "smpi_keyvals.hpp"
#include "xbt/synchro.h"
-#include <simgrid/msg.h>
#include <vector>
#include <list>
MPI_Comm comm_;
std::vector<MPI_Request> *requests_;
xbt_mutex_t mut_;
- msg_bar_t bar_;
+ simgrid::s4u::Barrier* bar_;
MPI_Win* connected_wins_;
char* name_;
int opened_;
#include "smpi_host.hpp"
#include "private.hpp"
-#include "simgrid/msg.h" /* barrier */
#include "simgrid/s4u/Engine.hpp"
#include "smpi_comm.hpp"
#include <map>
class Instance {
public:
Instance(const std::string name, int max_no_processes, int process_count, MPI_Comm comm,
- msg_bar_t finalization_barrier)
+ simgrid::s4u::Barrier* finalization_barrier)
: name(name)
, size(max_no_processes)
, present_processes(0)
int size;
int present_processes;
MPI_Comm comm_world;
- msg_bar_t finalization_barrier;
+ simgrid::s4u::Barrier* finalization_barrier;
};
}
}
}
}
- Instance instance(std::string(name), num_processes, process_count, MPI_COMM_NULL, MSG_barrier_init(num_processes));
+ Instance instance(std::string(name), num_processes, process_count, MPI_COMM_NULL,
+ new simgrid::s4u::Barrier(num_processes));
MPI_Group group = new simgrid::smpi::Group(instance.size);
instance.comm_world = new simgrid::smpi::Comm(group, nullptr);
MPI_Attr_put(instance.comm_world, MPI_UNIVERSE_SIZE, reinterpret_cast<void*>(instance.size));
return &instance.comm_world;
}
-msg_bar_t smpi_deployment_finalization_barrier(const std::string instance_id)
+simgrid::s4u::Barrier* smpi_deployment_finalization_barrier(const std::string instance_id)
{
if (smpi_instances.empty()) { // no instance registered, we probably used smpirun.
return nullptr;
void smpi_deployment_cleanup_instances(){
for (auto const& item : smpi_instances) {
Instance instance = item.second;
- MSG_barrier_destroy(instance.finalization_barrier);
+ delete instance.finalization_barrier;
simgrid::smpi::Comm::destroy(instance.comm_world);
}
smpi_instances.clear();
using simgrid::s4u::Actor;
using simgrid::s4u::ActorPtr;
-Process::Process(ActorPtr actor, msg_bar_t finalization_barrier)
+Process::Process(ActorPtr actor, simgrid::s4u::Barrier* finalization_barrier)
: finalization_barrier_(finalization_barrier), actor_(actor)
{
mailbox_ = simgrid::s4u::Mailbox::by_name("SMPI-" + std::to_string(actor_->get_pid()));
{
instance_id_ = std::string((*argv)[1]);
comm_world_ = smpi_deployment_comm_world(instance_id_);
- msg_bar_t barrier = smpi_deployment_finalization_barrier(instance_id_);
+ simgrid::s4u::Barrier* barrier = smpi_deployment_finalization_barrier(instance_id_);
if (barrier != nullptr) // don't overwrite the current one if the instance has none
finalization_barrier_ = barrier;
if(MC_is_active() || MC_record_replay_is_active())
return;
// wait for all pending asynchronous comms to finish
- MSG_barrier_wait(finalization_barrier_);
+ finalization_barrier_->wait();
}
/** @brief Check if a process is finalized */
connected_wins_[rank_] = this;
count_ = 0;
if(rank_==0){
- bar_ = MSG_barrier_init(comm_size);
+ bar_ = new simgrid::s4u::Barrier(comm_size);
}
mode_=0;
Colls::allgather(&(connected_wins_[rank_]), sizeof(MPI_Win), MPI_BYTE, connected_wins_, sizeof(MPI_Win),
MPI_BYTE, comm);
- Colls::bcast(&(bar_), sizeof(msg_bar_t), MPI_BYTE, 0, comm);
+ Colls::bcast(&(bar_), sizeof(simgrid::s4u::Barrier*), MPI_BYTE, 0, comm);
Colls::barrier(comm);
}
Win::~Win(){
//As per the standard, perform a barrier to ensure every async comm is finished
- MSG_barrier_wait(bar_);
+ bar_->wait();
int finished = finish_comms();
XBT_DEBUG("Win destructor - Finished %d RMA calls", finished);
Comm::unref(comm_);
if (rank_ == 0)
- MSG_barrier_destroy(bar_);
+ delete bar_;
xbt_mutex_destroy(mut_);
xbt_mutex_destroy(lock_mut_);
xbt_mutex_destroy(atomic_mut_);
opened_=1;
if (assert != MPI_MODE_NOPRECEDE) {
// This is not the first fence => finalize what came before
- MSG_barrier_wait(bar_);
+ bar_->wait();
xbt_mutex_acquire(mut_);
// This (simulated) mutex ensures that no process pushes to the vector of requests during the waitall.
// Without this, the vector could get redimensionned when another process pushes.
opened_=0;
assert_ = assert;
- MSG_barrier_wait(bar_);
+ bar_->wait();
XBT_DEBUG("Leaving fence");
return MPI_SUCCESS;
int i=0;
int retval = MPI_SUCCESS;
for (i=0; i<comm_->size();i++){
- int ret = this->unlock(i);
- if(ret != MPI_SUCCESS)
- retval = ret;
+ int ret = this->unlock(i);
+ if (ret != MPI_SUCCESS)
+ retval = ret;
}
return retval;
}
}
int Win::flush_all(){
- int i=0;
- int finished = 0;
- finished = finish_comms();
+ int finished = finish_comms();
XBT_DEBUG("Win_flush_all on local - Finished %d RMA calls", finished);
- for (i=0; i<comm_->size();i++){
+ for (int i = 0; i < comm_->size(); i++) {
finished = connected_wins_[i]->finish_comms(rank_);
XBT_DEBUG("Win_flush_all on %d - Finished %d RMA calls", i, finished);
}
return static_cast<Win*>(F2C::f2c(id));
}
-
int Win::finish_comms(){
xbt_mutex_acquire(mut_);
//Finish own requests
include/simgrid_config.h
include/simgrid/actor.h
+ include/simgrid/barrier.h
include/simgrid/engine.h
include/simgrid/chrono.hpp
include/simgrid/plugins/dvfs.h