Configuration.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstddef>
#include <tuple>
#include <type_traits>
#include <utility>
 
#include "autopas/containers/CompatibleLoadEstimators.h"
#include "autopas/containers/CompatibleTraversals.h"
#include "autopas/containers/CompatibleVectorizationPattern.h"
#include "autopas/options/ContainerOption.h"
#include "autopas/options/DataLayoutOption.h"
#include "autopas/options/LoadEstimatorOption.h"
#include "autopas/options/Newton3Option.h"
#include "autopas/options/TraversalOption.h"
#include "autopas/options/VectorizationPatternOption.h"
#include "autopas/utils/HashCombine.h"
 
namespace autopas {
 
class Configuration {
 public:
  constexpr Configuration(ContainerOption _container, double _cellSizeFactor, TraversalOption _traversal,
                          LoadEstimatorOption _loadEstimator, DataLayoutOption _dataLayout, Newton3Option _newton3,
                          InteractionTypeOption _interactionType, VectorizationPatternOption _vecPattern)
      : container(_container),
        traversal(_traversal),
        vecPattern(_vecPattern),
        loadEstimator(_loadEstimator),
        dataLayout(_dataLayout),
        newton3(_newton3),
        cellSizeFactor(_cellSizeFactor),
        interactionType(_interactionType) {}
 
  constexpr Configuration()
      : container(), traversal(), loadEstimator(), dataLayout(), newton3(), cellSizeFactor(-1.), interactionType() {}
 
  [[nodiscard]] std::string toString() const;
 
  [[nodiscard]] std::string toShortString(bool fixedLength = true, bool forParameterizedTestName = false) const {
    const std::string delimiter = forParameterizedTestName ? "_" : " , ";
    auto result = (forParameterizedTestName ? "" : "{") + interactionType.to_string() + delimiter +
                  container.to_string(fixedLength) + delimiter + std::to_string(cellSizeFactor) + delimiter +
                  traversal.to_string(fixedLength) + delimiter + loadEstimator.to_string(fixedLength) + delimiter +
                  dataLayout.to_string(fixedLength) + delimiter + newton3.to_string(fixedLength) + delimiter +
                  vecPattern.to_string(fixedLength) + (forParameterizedTestName ? "" : "}");
 
    // For parameterized test names, no punctuation is allowed except "_"
    if (forParameterizedTestName) {
      std::ranges::replace(result, '.', '_');
      std::ranges::replace(result, '-', '_');
      std::ranges::replace(result, '/', '_');
    }
 
    return result;
  }
 
  [[nodiscard]] std::string getCSVHeader() const;
 
  [[nodiscard]] std::string getCSVLine() const;
 
  [[nodiscard]] bool hasValidValues() const;
 
  [[nodiscard]] bool hasCompatibleValues() const;
 
  [[nodiscard]] auto tie() const {
    return std::tie(container, cellSizeFactor, traversal, loadEstimator, dataLayout, newton3, interactionType,
                    vecPattern);
  }
 
  [[nodiscard]] auto tie() {
    return std::tie(container, cellSizeFactor, traversal, loadEstimator, dataLayout, newton3, interactionType,
                    vecPattern);
  }
 
  ContainerOption container;
  TraversalOption traversal;
  VectorizationPatternOption vecPattern;
  LoadEstimatorOption loadEstimator;
  DataLayoutOption dataLayout;
  Newton3Option newton3;
  double cellSizeFactor;
  InteractionTypeOption interactionType;
 
 private:
  [[nodiscard]] std::string getCSVRepresentation(bool returnHeaderOnly) const;
};
 
std::ostream &operator<<(std::ostream &os, const Configuration &configuration);
 
std::istream &operator>>(std::istream &in, Configuration &configuration);
 
bool operator==(const Configuration &lhs, const Configuration &rhs);
 
bool operator!=(const Configuration &lhs, const Configuration &rhs);
 
bool operator<(const Configuration &lhs, const Configuration &rhs);
 
struct ConfigHash {
  std::size_t operator()(const Configuration &configuration) const {
    return std::apply([](const auto &...members) { return utils::hashCombine(members...); }, configuration.tie());
  }
};
 
namespace internal {
template <class Tuple_T, std::size_t... Is>
constexpr std::size_t sumOfMemberSizes(std::index_sequence<Is...>) {
  return (sizeof(std::remove_reference_t<std::tuple_element_t<Is, Tuple_T>>) + ...);
}
}  // namespace internal
 
using ConfigurationTie = decltype(std::declval<const Configuration &>().tie());
 
inline constexpr std::size_t serializedConfigurationSize =
    internal::sumOfMemberSizes<ConfigurationTie>(std::make_index_sequence<std::tuple_size_v<ConfigurationTie>>{});
 
}  // namespace autopas