TestContext.hpp

Go to the documentation of this file.

#pragma once
 
#include <set>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
 
#include "m2n/SharedPointer.hpp"
#include "precice/impl/Types.hpp"
#include "utils/Parallel.hpp"
 
namespace precice::testing {
 
struct Ranks {
  int value;
};
struct Ranks {…};
 
inline constexpr Ranks operator""_ranks(unsigned long long value)
{
  return (value <= 1) ? throw std::runtime_error{"Cannot create a single rank with _ranks()! Use _rank() instead!"} : Ranks{static_cast<int>(value)};
}
inline constexpr Ranks operator""_ranks(unsigned long long value) {…}
 
inline constexpr Ranks operator""_rank(unsigned long long value)
{
  return (value == 1) ? Ranks{1} : throw std::runtime_error{"Cannot create multiple ranks with _rank()! Use _ranks() instead!"};
}
inline constexpr Ranks operator""_rank(unsigned long long value) {…}
 
struct ParticipantState {
  std::string_view name;
 
  int size = 1;
 
  bool initIntraComm = false;
 
  constexpr explicit ParticipantState(std::string_view n)
      : name(std::move(n)) {};
  constexpr explicit ParticipantState(std::string_view n) {…}
 
  constexpr ParticipantState &operator()(Ranks rsize)
  {
    size = rsize.value;
    return *this;
  }
  constexpr ParticipantState &operator()(Ranks rsize) {…}
 
  constexpr ParticipantState &setupIntraComm()
  {
    initIntraComm = true;
    return *this;
  }
  constexpr ParticipantState &setupIntraComm() {…}
};
struct ParticipantState {…};
 
inline constexpr ParticipantState operator""_on(const char *name, std::size_t)
{
  return ParticipantState{name};
}
inline constexpr ParticipantState operator""_on(const char *name, std::size_t) {…}
 
static_assert(std::is_same<ParticipantState &, decltype(""_on(1_rank))>::value, "");
static_assert(std::is_same<ParticipantState &, decltype(""_on(2_ranks))>::value, "");
 
enum class Require {
  PETSc,
  Events,
  Ginkgo,
};
enum class Require {…};
 
struct TestSetup {
 
  template <class... T>
  TestSetup(T... args)
  {
    (handleOption(args), ...);
  }
  TestSetup(T... args) {…}
 
  void handleOption(ParticipantState participants);
  void handleOption(Ranks ranks);
  void handleOption(testing::Require requirement);
 
  int totalRanks() const;
 
  bool petsc = false;
 
  bool events = false;
 
  bool ginkgo = false;
 
  std::vector<ParticipantState> participants;
};
struct TestSetup {…};
 
enum struct ConnectionType {
  GatherScatter,
  PointToPoint
};
enum struct ConnectionType {…};
 
struct ConnectionOptions {
  ConnectionOptions() = default;
 
  bool useOnlyPrimaryCom = false;
 
  bool useTwoLevelInit = false;
 
  ConnectionType type = ConnectionType::GatherScatter;
};
struct ConnectionOptions {…};
 
class TestContext {
public:
  using Participants = std::vector<ParticipantState>;
 
  std::string name;
 
  Rank rank = 0;
 
  int size = 1;
 
  bool invalid = false;
 
  TestContext(TestSetup setup);
 
  ~TestContext() noexcept;
 
  std::string config() const;
 
  std::string prefix(const std::string &filename) const;
 
  bool hasSize(int size) const;
 
  bool isNamed(const std::string &name) const;
 
  bool isRank(Rank rank) const;
 
  auto comm()
  {
    return &(_contextComm->comm);
  }
  auto comm() {…}
 
  bool isPrimary() const;
 
  m2n::PtrM2N connectPrimaryRanks(const std::string &acceptor, const std::string &connector, const ConnectionOptions &options = ConnectionOptions{}) const;
 
  std::string describe() const;
 
private:
  TestSetup _setup;
 
  bool _initIntraComm = false;
 
  utils::Parallel::CommStatePtr _contextComm;
 
  std::set<std::string> _names;
 
  void setContextFrom(const ParticipantState &p);
 
 
  void initialize(const Participants &participants);
 
  void initializeMPI(const Participants &participants);
 
  void initializeIntraComm();
 
  void initializePetsc();
 
  void initializeEvents();
 
  void initializeGinkgo();
};
class TestContext {…};
 
} // namespace precice::testing