GenerateValidConfigurations.h

Go to the documentation of this file.

 
#pragma once
 
#include <set>
 
#include "autopas/options/ContainerOption.h"
#include "autopas/options/DataLayoutOption.h"
#include "autopas/options/InteractionTypeOption.h"
#include "autopas/options/LoadEstimatorOption.h"
#include "autopas/options/Newton3Option.h"
#include "autopas/options/TraversalOption.h"
#include "autopas/tuning/Configuration.h"
#include "autopas/tuning/utils/SearchSpaceGenerators.h"
#include "autopas/utils/NumberSetFinite.h"
 
struct ContainerConfiguration {
  autopas::ContainerOption container;
  double cellSizeFactor;
 
  bool operator==(const ContainerConfiguration &rhs) const {
    return container == rhs.container and cellSizeFactor == rhs.cellSizeFactor;
  }
 
  bool operator!=(const ContainerConfiguration &rhs) const { return not(*this == rhs); }
 
  bool operator<(const ContainerConfiguration &rhs) const {
    return std::tie(container, cellSizeFactor) < std::tie(rhs.container, rhs.cellSizeFactor);
  }
 
  [[nodiscard]] std::string toString() const {
    return "{Container: " + container.to_string() + " , CellSizeFactor: " + std::to_string(cellSizeFactor) + "}";
  }
};
 
inline std::ostream &operator<<(std::ostream &os, const ContainerConfiguration &configuration) {
  return os << configuration.toString();
}
 
inline std::set<autopas::Configuration> generateAllValidConfigurations(
    autopas::InteractionTypeOption interactionType,
    const std::set<autopas::ContainerOption> &allowedContainerOptions = autopas::ContainerOption::getAllOptions(),
    const std::set<autopas::TraversalOption> &allowedTraversalOptions = autopas::TraversalOption::getAllOptions(),
    const std::set<autopas::LoadEstimatorOption> &allowedLoadEstimatorOptions =
        autopas::LoadEstimatorOption::getAllOptions(),
    const std::set<autopas::DataLayoutOption> &allowedDataLayoutOptions = autopas::DataLayoutOption::getAllOptions(),
    const std::set<autopas::Newton3Option> &allowedNewton3Options = autopas::Newton3Option::getAllOptions(),
    const std::set<double> &allowedCellSizeFactors = {0.5, 1.0, 1.5},
    const std::set<autopas::VectorizationPatternOption> &allowedVectorPatterns =
        autopas::VectorizationPatternOption::getAllOptions()) {
  const autopas::NumberSetFinite<double> csfs(allowedCellSizeFactors);
  if (interactionType == autopas::InteractionTypeOption::all) {
    std::set<autopas::Configuration> allConfigs;
    for (auto iType : autopas::InteractionTypeOption::getMostOptions()) {
      const auto configs = autopas::SearchSpaceGenerators::cartesianProduct(
          allowedContainerOptions, allowedTraversalOptions, allowedLoadEstimatorOptions, allowedDataLayoutOptions,
          allowedNewton3Options, &csfs, allowedVectorPatterns, iType);
      allConfigs.insert(configs.begin(), configs.end());
    }
    return allConfigs;
  } else {
    return autopas::SearchSpaceGenerators::cartesianProduct(
        allowedContainerOptions, allowedTraversalOptions, allowedLoadEstimatorOptions, allowedDataLayoutOptions,
        allowedNewton3Options, &csfs, allowedVectorPatterns, interactionType);
  }
}
 
inline std::set<ContainerConfiguration> generateAllValidContainerConfigurations(
    const std::set<autopas::ContainerOption> &allowedContainerOptions = autopas::ContainerOption::getAllOptions(),
    const std::set<double> &allowedCellSizeFactors = {0.5, 1.0, 1.5}) {
  std::set<ContainerConfiguration> containerConfigs;
  for (const auto &containerOption : allowedContainerOptions) {
    for (const auto csf : allowedCellSizeFactors) {
      // Create a dummy configuration to check validity
      // We use pairwise interaction as default, since it should not matter for container/csf compatibility.
      // We also use the first valid traversal for this container.
      const auto interactionType = autopas::InteractionTypeOption(autopas::InteractionTypeOption::pairwise);
      const auto traversals = autopas::compatibleTraversals::allCompatibleTraversals(containerOption, interactionType);
      if (traversals.empty()) {
        autopas::utils::ExceptionHandler::exception(
            "{} has no compatible traversals with interaction type {}! This "
            "suggests that either that something is incorrect with this "
            "container or that generateAllValidContainerConfigurations's "
            "assumption that all containers have at least one {} compatible "
            "traversal no longer holds!",
            containerOption.to_string(), interactionType.to_string(), interactionType.to_string());
        continue;
      }
      const auto &traversalOption = *traversals.begin();
      const auto loadEstimators = autopas::loadEstimators::getApplicableLoadEstimators(
          containerOption, traversalOption, autopas::LoadEstimatorOption::getAllOptions());
      if (loadEstimators.empty()) {
        autopas::utils::ExceptionHandler::exception(
            "{} with traversal {} has no applicable load estimators! Either "
            "something is incorrect or generateAllValidContainerConfigurations's "
            "assumption that there is always an applicable load estimator (even "
            "if 'none') no longer holds.");
        continue;
      }
      const auto &loadEstimatorOption = *loadEstimators.begin();
 
      const autopas::Configuration configuration{containerOption,
                                                 csf,
                                                 traversalOption,
                                                 loadEstimatorOption,
                                                 autopas::DataLayoutOption::aos,
                                                 autopas::Newton3Option::enabled,
                                                 interactionType};
      if (configuration.hasCompatibleValues()) {
        containerConfigs.insert({containerOption, csf});
      }
    }
  }
  return containerConfigs;
}