AutoTuner.h

Go to the documentation of this file.

 
#pragma once
 
#include <memory>
#include <set>
#include <tuple>
 
#include "autopas/options/TuningMetricOption.h"
#include "autopas/tuning/Configuration.h"
#include "autopas/tuning/searchSpace/EvidenceCollection.h"
#include "autopas/tuning/tuningStrategy/LiveInfo.h"
#include "autopas/tuning/tuningStrategy/TuningStrategyInterface.h"
#include "autopas/tuning/utils/AutoTunerInfo.h"
#include "autopas/utils/EnergySensor.h"
#include "autopas/utils/SortingThresholdBenchmark.h"
#include "autopas/utils/Timer.h"
#include "autopas/utils/logging/TuningDataLogger.h"
#include "autopas/utils/logging/TuningResultLogger.h"
 
namespace autopas {
 
class AutoTuner {
 public:
  using TuningStrategiesListType = std::vector<std::unique_ptr<TuningStrategyInterface>>;
  using SearchSpaceType = std::set<Configuration>;
 
  AutoTuner(TuningStrategiesListType &tuningStrategies, const SearchSpaceType &searchSpace,
            const AutoTunerInfo &autoTunerInfo, unsigned int rebuildFrequency, const std::string &outputSuffix);
 
  AutoTuner &operator=(AutoTuner &&other) noexcept;
 
  ~AutoTuner();
 
  void forceRetune();
 
  const TuningMetricOption &getTuningMetric() const;
 
  void receiveLiveInfo(const LiveInfo &liveInfo, bool isStartOfTuningPhase);
 
  [[nodiscard]] bool needsLiveInfo() const;
 
  [[nodiscard]] bool needsDomainSimilarityStatistics() const;
 
  bool willRebuildNeighborLists() const;
 
  [[nodiscard]] const Configuration &getCurrentConfig() const;
 
  [[nodiscard]] Configuration rejectConfig(const Configuration &rejectedConfig, bool indefinitely, size_t tuningPhase);
 
  bool searchSpaceIsTrivial() const;
 
  bool searchSpaceIsEmpty() const;
 
  void logTuningResult(long tuningTime, size_t currentIteration) const;
 
  bool initEnergy();
 
  bool resetEnergy();
 
  std::tuple<double, double, double, long> sampleEnergy();
 
  void addMeasurement(long sampleRebuild, long sampleTraverseParticles, bool neighborListRebuilt, size_t iteration,
                      size_t tuningPhase);
 
  void addDomainSimilarityStatistics(double pdBinDensityStdDev, double pdBinMaxDensity);
 
  const std::vector<Configuration> &getConfigQueue() const;
 
  const std::vector<std::unique_ptr<TuningStrategyInterface>> &getTuningStrategies() const;
 
  bool inTuningPhase() const;
 
  bool inLastTuningIteration() const;
 
  const EvidenceCollection &getEvidenceCollection() const;
 
  bool canMeasureEnergy() const;
 
  void setRebuildFrequency(double rebuildFrequency);
 
  void checkEarlyStoppingCondition(size_t tuningPhase);
 
  bool tuneConfiguration(size_t currentIteration, size_t tuningPhase, bool isStartOfTuningPhase);
 
  void setOptimalConfiguration(const Configuration &optimalConfig);
 
  const std::set<Configuration> &getSearchSpace() const;
 
  SortingThresholdBenchmark &getSortingThresholdBenchmark() { return _sortingThresholdBenchmark; }
 
 private:
  SortingThresholdBenchmark _sortingThresholdBenchmark;
 
  void handleEndOfTuningPhase(size_t tuningPhase);
 
  void selectBestConfiguration(size_t tuningPhase);
 
  size_t getCurrentNumSamples() const;
 
  [[nodiscard]] std::tuple<long, long, long> estimateRuntimeFromSamples() const;
 
  SelectorStrategyOption _selectorStrategy;
 
  std::vector<std::unique_ptr<TuningStrategyInterface>> _tuningStrategies;
 
  TuningMetricOption _tuningMetric;
 
  bool _useLOESSSmoothening;
 
  bool _energyMeasurementPossible;
 
  double _rebuildFrequency;
 
  size_t _maxSamples;
 
  double _earlyStoppingFactor;
 
  bool _needsDomainSimilarityStatistics;
 
  bool _needsLiveInfo;
 
  std::vector<double> _pdBinDensityStdDevOfLastTenIterations{};
 
  std::vector<double> _pdBinMaxDensityOfLastTenIterations{};
 
  std::vector<long> _samplesTraverseInteractions;
 
  std::vector<long> _samplesRebuildingNeighborLists{};
 
  EvidenceCollection _evidenceCollection{};
 
  SearchSpaceType _searchSpace;
 
  std::vector<Configuration> _configQueue;
 
  TuningResultLogger _tuningResultLogger;
 
  TuningDataLogger _tuningDataLogger;
 
  utils::EnergySensor _energySensor;
 
  bool _isTuning{false};
 
  bool _endOfTuningPhase{false};
 
  bool _forceRetune{false};
 
  bool _earlyStoppingOfResampling{false};
};
}  // namespace autopas