ActiveHarmony.h

Go to the documentation of this file.

 
#pragma once
 
#include <chrono>
#include <cstdio>
#include <cstdlib>
#include <string>
#include <thread>
#include <vector>
 
#include "TuningStrategyInterface.h"
#include "autopas/containers/CompatibleLoadEstimators.h"
#include "autopas/containers/CompatibleTraversals.h"
#include "autopas/containers/LoadEstimators.h"
#include "autopas/tuning/Configuration.h"
#include "autopas/tuning/searchSpace/EvidenceCollection.h"
#include "autopas/utils/AutoPasConfigurationCommunicator.h"
#include "autopas/utils/WrapMPI.h"
 
#ifdef AUTOPAS_ENABLE_HARMONY
#include "hclient.h"
#endif
 
namespace autopas {
 
class ActiveHarmony : public TuningStrategyInterface {
 public:
  ActiveHarmony(const InteractionTypeOption &interactionType, const std::set<ContainerOption> &allowedContainerOptions,
                const NumberSet<double> &allowedCellSizeFactors,
                const std::set<TraversalOption> &allowedTraversalOptions,
                const std::set<LoadEstimatorOption> &allowedLoadEstimatorOptions,
                const std::set<DataLayoutOption> &allowedDataLayoutOptions,
                const std::set<Newton3Option> &allowedNewton3Options,
                const std::set<VectorizationPatternOption> &allowedVecPatternOptions, bool mpiDivideAndConquer,
                AutoPas_MPI_Comm comm);
 
  ~ActiveHarmony() override;
 
  TuningStrategyOption getOptionType() const override;
 
  void addEvidence(const Configuration &configuration, const Evidence &evidence) override;
 
  bool optimizeSuggestions(std::vector<Configuration> &configQueue,
                           const EvidenceCollection &evidenceCollection) override;
 
  bool searchSpaceIsTrivial() const;
 
  bool searchSpaceIsEmpty() const;
 
  bool needsDomainSimilarityStatistics() const override;
 
  bool reset(size_t iteration, size_t tuningPhase, std::vector<Configuration> &configQueue,
             const autopas::EvidenceCollection &evidenceCollection) override;
 
 private:
#ifdef AUTOPAS_ENABLE_HARMONY
  hdesc_t *hdesc = nullptr;
  htask_t *htask = nullptr;
#else
  using hdef_t = void *;
#endif
 
  const InteractionTypeOption _interactionType;
 
  std::set<ContainerOption> _allowedContainerOptions;
  std::unique_ptr<NumberSet<double>> _allowedCellSizeFactors;
  std::set<TraversalOption> _allowedTraversalOptions;
  std::set<LoadEstimatorOption> _allowedLoadEstimatorOptions;
  std::set<DataLayoutOption> _allowedDataLayoutOptions;
  std::set<Newton3Option> _allowedNewton3Options;
  std::set<VectorizationPatternOption> _allowedVecPatterns;
 
  size_t _tuningPhase{0};
  bool _mpiDivideAndConquer;
  AutoPas_MPI_Comm _comm;
  bool _nonLocalServer;
 
  void resetHarmony();
 
  Configuration fetchConfiguration();
 
  void invalidateConfiguration();
 
  template <class OptionClass>
  void configureTuningParameter(hdef_t *hdef, const char *name, const std::set<OptionClass> &options);
 
  template <class OptionClass>
  OptionClass fetchTuningParameter(const char *name, const std::set<OptionClass> &options);
 
  void rejectConfiguration(const autopas::Configuration &configuration, bool indefinitely) override;
 
  void setupTuningParameters(int commSize, hdef_t *hdef);
 
  static constexpr int cellSizeSamples = 100;
 
  static constexpr const char *traversalOptionName = "traversalOption";
  static constexpr const char *loadEstimatorOptionName = "loadEstimatorOption";
  static constexpr const char *dataLayoutOptionName = "dataLayoutOption";
  static constexpr const char *cellSizeFactorsName = "cellSizeFactor";
  static constexpr const char *newton3OptionName = "newton3Option";
  static constexpr const char *vecPatternOptionName = "vectorPattern";
};
 
}  // namespace autopas