TestContext.hpp

Go to the documentation of this file.

#pragma once
 
#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 {
namespace testing {
 
struct Ranks {
  int value;
};
 
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""_rank(unsigned long long value)
{
  return (value == 1) ? Ranks{1} : throw std::runtime_error{"Cannot create multiple ranks with _rank()! Use _ranks() instead!"};
}
 
struct ParticipantState {
  std::string name;
 
  int size = 1;
 
  bool initIntraComm = false;
 
  explicit ParticipantState(std::string n)
      : name(std::move(n)){};
 
  ParticipantState &operator()(Ranks rsize)
  {
    size = rsize.value;
    return *this;
  }
 
  ParticipantState &setupIntraComm()
  {
    initIntraComm = true;
    return *this;
  }
};
 
inline ParticipantState operator""_on(const char *name, std::size_t)
{
  return ParticipantState{name};
}
 
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,
};
 
enum struct ConnectionType {
  GatherScatter,
  PointToPoint
};
 
struct ConnectionOptions {
  ConnectionOptions() = default;
 
  bool useOnlyPrimaryCom = false;
 
  bool useTwoLevelInit = false;
 
  ConnectionType type = ConnectionType::GatherScatter;
};
 
class TestContext {
public:
  using Participants = std::vector<ParticipantState>;
 
  std::string name;
 
  Rank rank = 0;
 
  int size = 1;
 
  bool invalid = false;
 
 
  TestContext() = default;
 
  template <class... T>
  TestContext(Ranks ranks)
      : _simple(true)
  {
    Participants participants{"Serial"_on(ranks)};
    initialize(participants);
  }
 
  template <class... T>
  TestContext(Ranks ranks, T... args)
      : _simple(true)
  {
    Participants participants{"Serial"_on(ranks)};
    handleOptions(participants, args...);
    initialize(participants);
  }
 
  template <class... T>
  TestContext(T... args)
  {
    Participants participants;
    handleOptions(participants, args...);
    initialize(participants);
  }
 
 
  ~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);
  }
 
  bool isPrimary() const;
 
  m2n::PtrM2N connectPrimaryRanks(const std::string &acceptor, const std::string &requestor, const ConnectionOptions &options = ConnectionOptions{}) const;
 
  std::string describe() const;
 
private:
  bool _petsc = false;
 
  bool _events = false;
 
  bool _simple = false;
 
  bool _initIntraComm = false;
 
  utils::Parallel::CommStatePtr _contextComm;
 
  std::vector<std::string> _names;
 
  void handleOption(Participants &participants, ParticipantState participant);
  void handleOption(Participants &participants, testing::Require requirement);
 
  template <class LastOption>
  void handleOptions(Participants &participants, LastOption &last)
  {
    handleOption(participants, last);
  }
 
  template <class NextOption, class... Rest>
  void handleOptions(Participants &participants, NextOption &next, Rest &... rest)
  {
    handleOption(participants, next);
    handleOptions(participants, rest...);
  }
 
  void setContextFrom(const ParticipantState &p);
 
 
  void initialize(const Participants &participants);
 
  void initializeMPI(const Participants &participants);
 
  void initializeIntraComm();
 
  void initializePetsc();
 
  void initializeEvents();
 
};
 
} // namespace testing
} // namespace precice