RuleBasedProgramTree.h

#pragma once
 
#include "RuleVM.h"
 
namespace autopas {
 
enum class Type { BOOL, DOUBLE, SIZE_T, CONTAINER, TRAVERSAL, LOAD_ESTIMATOR, DATA_LAYOUT, NEWTON3, CELL_SIZE_FACTOR };
 
struct ConfigurationPattern {
  std::set<ContainerOption> _containers;
  std::set<TraversalOption> _traversals;
  std::set<LoadEstimatorOption> _loadEstimators;
  std::set<DataLayoutOption> _dataLayouts;
  std::set<Newton3Option> _newton3Options;
  std::set<double> _cellSizeFactors;
 
  ConfigurationPattern();
 
  ConfigurationPattern(const ConfigurationPattern &configurationPattern);
 
  ~ConfigurationPattern() noexcept;
 
  void add(const RuleVM::MemoryCell &value) {
    std::visit(
        [&](const auto &val) {
          addHelper(val, _containers, _traversals, _loadEstimators, _dataLayouts, _newton3Options, _cellSizeFactors);
        },
        value);
  }
 
  [[nodiscard]] bool matches(const Configuration &configuration) const {
    return (_containers.empty() or contains(_containers, configuration.container)) and
           (_traversals.empty() or contains(_traversals, configuration.traversal)) and
           (_loadEstimators.empty() or contains(_loadEstimators, configuration.loadEstimator)) and
           (_dataLayouts.empty() or contains(_dataLayouts, configuration.dataLayout)) and
           (_newton3Options.empty() or contains(_newton3Options, configuration.newton3)) and
           (_cellSizeFactors.empty() or contains(_cellSizeFactors, configuration.cellSizeFactor));
  }
 
  [[nodiscard]] std::string toString() const {
    std::string res = optionSetToString(_containers) + "; " + optionSetToString(_traversals) + "; " +
                      optionSetToString(_loadEstimators) + "; " + optionSetToString(_loadEstimators) + "; " +
                      optionSetToString(_dataLayouts) + "; " + optionSetToString(_newton3Options) + "; ";
    if (not _cellSizeFactors.empty()) {
      res += std::accumulate(std::next(_cellSizeFactors.begin()), _cellSizeFactors.end(),
                             std::to_string(*_cellSizeFactors.begin()),
                             [](std::string s, double d) { return std::move(s) + ',' + std::to_string(d); });
    }
    return res;
  }
 
 private:
  template <class T>
  [[nodiscard]] static std::string optionSetToString(const std::set<T> &set) {
    if (not set.empty()) {
      auto comma_fold = [](std::string a, T b) { return std::move(a) + ',' + b.to_string(); };
 
      return std::accumulate(std::next(set.begin()), set.end(), set.begin()->to_string(), comma_fold);
    }
    return {};
  }
 
  template <typename T>
  [[nodiscard]] static bool contains(const std::set<T> &set, const T &option) {
    return set.find(option) != set.end();
  }
 
  template <class T, class SetT>
  static void addHelper2(T value, SetT &set) {
    if constexpr (std::is_same_v<T, typename SetT::value_type>) {
      set.insert(value);
    }
  }
 
  template <class T, class... SetT>
  static void addHelper(T value, SetT &...sets) {
    (addHelper2(value, sets), ...);
  }
};
 
namespace RuleSyntax {
 
class CodeGenerationContext;
 
struct Define;
 
struct Statement {
  virtual ~Statement() = default;
  virtual void generateCode(CodeGenerationContext &context, RuleVM::Program &program) const = 0;
};
 
inline Type typeOf(const RuleVM::MemoryCell &memoryCell) { return static_cast<Type>(memoryCell.index()); }
 
struct Expression {
  virtual ~Expression() = default;
  [[nodiscard]] virtual Type getType() const = 0;
  virtual void generateCode(CodeGenerationContext &context, RuleVM::Program &program) const = 0;
};
 
struct DefineList;
 
struct ConfigurationOrder : public Statement {
  ConfigurationPattern greater;
  ConfigurationPattern smaller;
 
  enum class SameProperty { container, traversal, dataLayout, newton3, loadEstimator, cellSizeFactor };
 
  std::vector<SameProperty> sameProperties;
 
  ConfigurationOrder() = default;
 
  ~ConfigurationOrder() override = default;
  ConfigurationOrder(ConfigurationPattern greater, ConfigurationPattern smaller, std::vector<SameProperty> same = {});
 
  void generateCode(CodeGenerationContext &context, RuleVM::Program &program) const override;
 
  [[nodiscard]] std::string toString() const;
 
  [[nodiscard]] bool haveEqualSameProperties(const Configuration &conf1, const Configuration &conf2) const;
 
 private:
  static std::string samePropertyToString(SameProperty same);
};
 
class CodeGenerationContext {
 public:
  explicit CodeGenerationContext(std::map<std::string, std::pair<const Define *, size_t>> initialAddressEnvironment);
 
  ~CodeGenerationContext();
 
  void allocateStack(size_t num);
 
  void freeStack(size_t num);
 
  void addLocalVariable(const Define &definition);
 
  void addGlobalVariable(const Define &definition);
 
  [[nodiscard]] size_t addressOf(const std::string &name) const;
 
  [[nodiscard]] const Define *definitionOf(const std::string &name) const;
 
  [[nodiscard]] auto getMaxStackSize() const { return maxNeededStack; }
 
  void addList(const std::string &name, const DefineList *list);
 
  const DefineList *getList(const std::string &name);
 
  size_t addConfigurationOrder(const ConfigurationOrder &configurationOrder);
 
  [[nodiscard]] const std::vector<ConfigurationOrder> &getConfigurationOrders() const;
 
  [[nodiscard]] ConfigurationPattern smallerConfigurationPatternByIndex(size_t idx) const;
 
  [[nodiscard]] size_t getNumLocalVariables() const;
 
 private:
  size_t currentNeededStack;
  size_t maxNeededStack;
 
  std::map<std::string, std::pair<const Define *, size_t>> addressEnvironment;
  size_t initialNumVariables;
  std::map<std::string, const DefineList *> lists;
  std::vector<ConfigurationOrder> configurationOrders;
};
 
struct Literal : public Expression {
  RuleVM::MemoryCell value;
  Type type;
 
  explicit Literal(RuleVM::MemoryCell value);
 
  [[nodiscard]] Type getType() const override;
 
  void generateCode(CodeGenerationContext &context, RuleVM::Program &program) const override;
};
 
struct DefineList : public Statement {
  std::string listName;
  std::vector<Literal> values;
 
  DefineList(std::string listName, std::vector<Literal> values);
 
  void generateCode(CodeGenerationContext &context, RuleVM::Program &program) const override;
};
 
struct Variable : public Expression {
  const Define *definition;
 
  explicit Variable(const Define *definition) : definition(definition) {}
 
  [[nodiscard]] Type getType() const override;
 
  void generateCode(CodeGenerationContext &context, RuleVM::Program &program) const override;
};
 
struct UnaryOperator : public Expression {
  enum Operator { NOT };
 
  std::shared_ptr<Expression> child;
  Operator op;
 
  UnaryOperator(Operator op, std::shared_ptr<Expression> child);
 
  [[nodiscard]] Type getType() const override;
 
  void generateCode(CodeGenerationContext &context, RuleVM::Program &program) const override;
};
 
struct BinaryOperator : public Expression {
  enum Operator { LESS, GREATER, AND, OR, ADD, SUB, MUL, DIV };
 
  std::shared_ptr<Expression> left;
  Operator op;
  std::shared_ptr<Expression> right;
 
  BinaryOperator(Operator op, std::shared_ptr<Expression> left, std::shared_ptr<Expression> right);
 
  [[nodiscard]] Type getType() const override;
 
  void generateCode(CodeGenerationContext &context, RuleVM::Program &program) const override;
};
 
struct Define : public Statement {
  std::string variable;
  std::shared_ptr<Expression> value;
 
  Define(std::string variable, std::shared_ptr<Expression> value);
 
  ~Define() override;
 
  void generateCode(CodeGenerationContext &context, RuleVM::Program &program) const override;
};
 
struct If : public Statement {
  std::shared_ptr<Expression> condition;
  std::vector<std::shared_ptr<Statement>> consequences;
 
  If(std::shared_ptr<Expression> condition, std::vector<std::shared_ptr<Statement>> consequences);
 
  void generateCode(CodeGenerationContext &context, RuleVM::Program &program) const override;
};
 
struct RuleBasedProgramTree {
  std::vector<std::shared_ptr<Statement>> statements;
 
  [[nodiscard]] RuleVM::Program generateCode(CodeGenerationContext &context) const;
};
 
}  // namespace RuleSyntax
}  // namespace autopas