RuleBasedTuning.h

Go to the documentation of this file.

 
#pragma once
 
#include <fstream>
#include <list>
#include <unordered_map>
 
#ifdef AUTOPAS_ENABLE_RULES_BASED_AND_FUZZY_TUNING
#include "RuleBasedProgramParser.h"
#include "RuleBasedProgramTree.h"
#include "RuleVM.h"
#include "autopas/utils/WrapMPI.h"
#endif
 
#include "autopas/tuning/Configuration.h"
#include "autopas/tuning/searchSpace/EvidenceCollection.h"
#include "autopas/tuning/tuningStrategy/TuningStrategyInterface.h"
#include "autopas/utils/logging/Logger.h"
 
namespace autopas {
class RuleBasedTuning : public TuningStrategyInterface {
 public:
  using PrintTuningErrorFunType =
#ifdef AUTOPAS_ENABLE_RULES_BASED_AND_FUZZY_TUNING
      std::function<void(const RuleSyntax::ConfigurationOrder &order, const Configuration &actualBetterConfig,
                         unsigned long betterRuntime, const Configuration &shouldBeBetterConfig,
                         unsigned long shouldBeBetterRuntime, const LiveInfo &liveInfo)>;
#else
      int;  // This is simply a dummy type and will never be used.
#endif
 
  explicit RuleBasedTuning(const std::set<Configuration> &searchSpace, bool verifyModeEnabled = false,
                           std::string ruleFileName = "tuningRules.rule",
                           PrintTuningErrorFunType tuningErrorPrinter = {});
 
  TuningStrategyOption getOptionType() const override;
 
  bool needsLiveInfo() const override;
 
  void receiveLiveInfo(const LiveInfo &info) override;
 
  void addEvidence(const Configuration &configuration, const Evidence &evidence) override;
 
  bool reset(size_t iteration, size_t tuningPhase, std::vector<Configuration> &configQueue,
             const autopas::EvidenceCollection &evidenceCollection) override;
 
  [[nodiscard]] long getLifetimeWouldHaveSkippedTuningTime() const;
 
  [[nodiscard]] long getLifetimeTuningTime() const;
 
  bool optimizeSuggestions(std::vector<Configuration> &configQueue,
                           const EvidenceCollection &evidenceCollection) override;
 
 private:
#ifdef AUTOPAS_ENABLE_RULES_BASED_AND_FUZZY_TUNING
  std::string rulesToString(const std::string &filePath) const;
 
  void verifyCurrentConfigTime(const Configuration &configuration) const;
 
  std::vector<RuleSyntax::ConfigurationOrder> applyRules(const std::vector<Configuration> &searchSpace);
 
  std::vector<RuleSyntax::ConfigurationOrder> _lastApplicableConfigurationOrders{};
 
  // The following member variables are only conditionally compiled to avoid warnings about unused variables.
 
  bool _verifyModeEnabled{};
  long _tuningTime{0};
  long _wouldHaveSkippedTuningTime{0};
  bool _rulesTooHarsh{false};
  PrintTuningErrorFunType _tuningErrorPrinter{};
#endif
 
  std::set<Configuration> _searchSpace{};
  std::list<Configuration> _originalSearchSpace{};
  std::set<Configuration> _removedConfigurations{};
 
  std::string _ruleFileName{};
 
  std::unordered_map<Configuration, long, ConfigHash> _traversalTimes{};
 
  long _tuningTimeLifetime{0};
  long _wouldHaveSkippedTuningTimeLifetime{0};
 
  LiveInfo _currentLiveInfo{};
};
}  // namespace autopas