Parallel.hpp

Go to the documentation of this file.

#pragma once
 
#include <iosfwd>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
#include "logging/Logger.hpp"
#include "precice/impl/Types.hpp"
 
#ifndef PRECICE_NO_MPI
#include <mpi.h>
#endif // not PRECICE_NO_MPI
 
namespace precice {
namespace logging {
class Logger;
} // namespace logging
 
namespace utils {
 
class Parallel {
public:
#ifndef PRECICE_NO_MPI
  using Communicator = MPI_Comm;
#else
  using Communicator = std::nullptr_t;
#define MPI_COMM_NULL nullptr
#endif
 
  struct CommState;
 
  using CommStatePtr = std::shared_ptr<CommState>;
 
  struct CommState {
    Communicator comm = MPI_COMM_NULL;
 
    CommStatePtr parent = nullptr;
 
    bool _owning = true;
 
    CommState() = default;
 
    CommState(const CommState &) = delete;
    CommState &operator=(const CommState &) = delete;
 
    CommState(CommState &&) noexcept;
    CommState &operator=(CommState &&) noexcept;
 
    ~CommState() noexcept;
 
 
 
    static CommStatePtr world();
 
    static CommStatePtr null();
 
    static CommStatePtr self();
 
    static CommStatePtr fromComm(Communicator comm);
 
    static CommStatePtr fromExtern(Communicator comm);
 
 
 
    Rank rank() const;
 
    int size() const;
 
    bool isNull() const;
 
 
 
    void synchronize() const;
 
    void print(std::ostream &out) const;
 
  };
 
 
  static bool isMPIInitialized();
 
  static void initializeOrDetectMPI(std::optional<Communicator> userProvided = std::nullopt);
 
  static void finalizeOrCleanupMPI();
 
  static void initializeTestingMPI(
      int *   argc,
      char ***argv);
 
  static void finalizeTestingMPI();
 
 
 
  static void splitCommunicator(std::optional<int> group = std::nullopt);
 
  static void resetCommState();
 
  static void resetManagedMPI();
 
  static void popState();
 
 
  static Rank getProcessRank();
 
  static CommStatePtr current();
 
 
private:
  static logging::Logger _log;
 
  static CommStatePtr _currentState;
 
  static bool _mpiInitializedByPrecice;
 
  enum struct InitializationState {
    Uninitialized, 
    Provided,      
    Managed,       
    Unmanaged,     
    Testing        
  };
 
  static InitializationState _initState;
 
  static void pushState(CommStatePtr newState);
};
 
std::ostream &operator<<(std::ostream &out, const Parallel::CommState &value);
 
} // namespace utils
} // namespace precice
 
template <>
struct fmt::formatter<precice::utils::Parallel::CommState> : ostream_formatter {
};