PCU.h

Go to the documentation of this file.

#ifndef SCOREC_PCU_H
#define SCOREC_PCU_H
 
#include <memory>
#include <cstdlib>
#include <cstdarg> //va_list
#include "pcu_defines.h"
 
struct pcu_msg_struct;
struct pcu_mpi_struct;
 
namespace pcu {
class PCU {
public:
  PCU();
  explicit PCU(PCU_Comm comm);
  ~PCU() noexcept;
  PCU(PCU const &) = delete;
  PCU(PCU &&) noexcept;
  PCU &operator=(PCU const &) = delete;
  PCU &operator=(PCU &&) noexcept;
  [[nodiscard]] int Self() const noexcept;
  [[nodiscard]] int Peers() const noexcept;
 
  [[nodiscard]] PCU_t GetCHandle() {PCU_t h; h.ptr=this; return h;}
  /*recommended message passing API*/
  void Begin() noexcept;
  int Pack(int to_rank, const void *data, size_t size) noexcept;
  template<typename T> int Pack(int to_rank, const T& data) noexcept {
    return Pack(to_rank, &(data), sizeof(data));
  }
 
  int Send() noexcept;
  bool Receive() noexcept;
  bool Listen() noexcept;
  int Sender() noexcept;
  bool Unpacked() noexcept;
  int Unpack(void *data, size_t size) noexcept;
  template<typename T> int Unpack(T& data) noexcept {
    return Unpack(&(data), sizeof(data));
  }
  /*IPComMan replacement API*/
  int Write(int to_rank, const void *data, size_t size) noexcept;
  bool Read(int *from_rank, void **data, size_t *size) noexcept;
 
  /*turns deterministic ordering for the
    above API on/off*/
  void Order(bool on);
 
  /*collective operations*/
  void Barrier();
  template <typename T> void Add(T *p, size_t n) noexcept;
  template <typename T> [[nodiscard]] T Add(T p) noexcept;
  template <typename T> void Min(T *p, size_t n) noexcept;
  template <typename T> [[nodiscard]] T Min(T p) noexcept;
  template <typename T> void Max(T *p, size_t n) noexcept;
  template <typename T> [[nodiscard]] T Max(T p) noexcept;
  template <typename T> void Exscan(T *p, size_t n) noexcept;
  template <typename T> [[nodiscard]] T Exscan(T p) noexcept;
  template <typename T>
  void Allgather(const T *send, T *recv, size_t n) noexcept;
 
  /*bitwise operations*/
  [[nodiscard]] int Or(int c) noexcept;
  [[nodiscard]] int And(int c) noexcept;
 
  std::unique_ptr<PCU> Split(int color, int key) noexcept;
 
  int DupComm(PCU_Comm* newcomm) const noexcept;
 
  /*lesser-used APIs*/
  int Packed(int to_rank, size_t *size) noexcept;
  int From(int *from_rank) noexcept;
  int Received(size_t *size) noexcept;
  void *Extract(size_t size) noexcept;
 
  /*
   * Debug print function with printf-style formatting
   * This function is excluded from SWIG parsing due to complex macro usage
   * with variadic argument. Also, such functionalities is not needed for the Python API.
   */
  #ifndef SWIG
  void DebugPrint(const char* format, ...) noexcept PCU_FORMAT_ATTRIBUTE(2, 3)
  void DebugPrint(const char* format, va_list args) noexcept;
  #endif // SWIG
  /* Debug functions */
  void DebugOpen() noexcept;
 
private:
  pcu_msg_struct *msg_;
  pcu_mpi_struct *mpi_;
};
/*stack trace helpers using GNU/Linux*/
void Protect() noexcept;
/*Memory usage*/
[[nodiscard]] double GetMem() noexcept;
/*MPI_Wtime() equivalent*/
[[nodiscard]] double Time() noexcept;
 
void Init(int *argc, char ***argv);
void Finalize();
 
/*
 * Explicit instantiations of template functions,
 * ignored by SWIG to avoid difficulties when parsing macros involving
 * template functions. Templates are initialized manually in the interface file.
 */
#ifndef SWIG
#define PCU_EXPL_INST_DECL(T)                                                  \
  extern template void PCU::Add<T>(T * p, size_t n) noexcept;                  \
  extern template T PCU::Add<T>(T p) noexcept;                                 \
  extern template void PCU::Min<T>(T * p, size_t n) noexcept;                  \
  extern template T PCU::Min<T>(T p) noexcept;                                 \
  extern template void PCU::Max<T>(T * p, size_t n) noexcept;                  \
  extern template T PCU::Max<T>(T p) noexcept;                                 \
  extern template void PCU::Exscan<T>(T * p, size_t n) noexcept;               \
  extern template T PCU::Exscan<T>(T p) noexcept;                              \
  extern template                                                              \
  void PCU::Allgather<T>(const T *send, T *recv, size_t n) noexcept;
PCU_EXPL_INST_DECL(int)
PCU_EXPL_INST_DECL(size_t)
PCU_EXPL_INST_DECL(long)
PCU_EXPL_INST_DECL(double)
#undef PCU_EXPL_INST_DECL
#endif // SWIG
 
} // namespace pcu
 
#endif // PCUOBJ_H