SchedulerBase.h

Go to the documentation of this file.

#ifndef RDFAnalysis_SchedulerBase_H
#define RDFAnalysis_SchedulerBase_H

#include "RDFAnalysis/IBranchNamer.h"

#include <string>
#include <map>
#include <set>
#include <vector>

namespace RDFAnalysis {
  class SchedulerBase {
    public:
      enum ActionType {
        FILTER,
        VARIABLE,
        FILL,
        INVALID
      };
      static std::string actionTypeToString(ActionType type);

      struct RegionDef {
        std::vector<std::string> filterList;
        std::set<std::string> fills;
        void addFill(const std::string& fill) {fills.insert(fill); }
      }; //> end struct RegionDef

      RegionDef& addRegion(
          const std::string& name,
          const std::vector<std::string>& filterList);

      std::map<std::string, RegionDef>& regionDefs()
      { return m_regionDefs;}
      const std::map<std::string, RegionDef>& regionDefs() const
      { return m_regionDefs;}

      void filterSatisfies(
          const std::string& filter,
          const std::vector<std::string>& satisfied);

      struct Action {
        Action(ActionType type, const std::string& name, float cost = 0) :
          type(type), name(name), cost(cost) {}

        ActionType type;
        std::string name;
        float cost;

        bool operator<(const Action& rhs) const {
          return (type == rhs.type ? name < rhs.name : type < rhs.type);
        }
        bool operator==(const Action& rhs) const {
          return type == rhs.type && name == rhs.name;
        }
        struct CostOrdering {
          bool operator()(const Action& lhs, const Action& rhs) const
          {
            return (lhs.cost == rhs.cost ? lhs < rhs : lhs.cost < rhs.cost);
          }
        }; //> end struct CostOrdering

        std::map<Action, std::set<Action>, CostOrdering> expand(
            const SchedulerBase& scheduler,
            const std::set<Action>& preExisting = {}) const;
        std::map<Action, std::set<Action>, CostOrdering> expand(
            const SchedulerBase& scheduler,
            const std::set<Action>& preExisting,
            std::vector<Action>& processing) const;

        void retrieveCost(const SchedulerBase& scheduler);
      }; //> end struct Action

      struct ScheduleNode {
        ScheduleNode(const Action& action) : action(action) {}
        Action action;
        std::map<Action, std::set<Action>, Action::CostOrdering> dependencies;
        std::vector<ScheduleNode> children;
        std::string region;

        const Action& next() const;

        void removeDependency(Action action, const SchedulerBase& scheduler);

        void expand(
            const SchedulerBase& scheduler,
            const std::set<Action>& preExisting = {})
        { dependencies = action.expand(scheduler, preExisting); }
      }; //> end struct ScheduleNode

      static void printSchedule(std::ostream& os, const ScheduleNode& root);

      ScheduleNode& getSchedule() { return m_schedule; }
      const ScheduleNode& getSchedule() const { return m_schedule; }

      const std::vector<std::string>& usedVariables() const { return m_usedVars; }

      const std::set<Action>& getDependencies(const Action& action) const;

      float getCost(const Action& action) const;

      bool isActionSatisfiedBy(
          const Action& action,
          const std::set<Action>& candidates,
          bool considerSelf = true) const;

      bool isActionSatisfiedBy(
          const Action& action,
          const std::set<Action>& candidates,
          Action& satisfiedBy,
          bool considerSelf = true) const;
    protected:

      void addAction(
          const Action& action,
          const std::set<Action>& dependencies);

      std::map<Action, Action> buildReplacementMap(
          const std::set<Action>& filters) const;

      void actionDefinesMultipleVariables(
          const std::string& name,
          const std::vector<std::string>& defined);

      ScheduleNode& schedule(const IBranchNamer& namer);


      ScheduleNode rawSchedule() const;

    private:
      void addChildren(
          std::vector<ScheduleNode>&& sources,
          ScheduleNode* target,
          std::set<Action> preExisting);
      std::map<std::string, RegionDef> m_regionDefs;

      std::map<Action, std::set<Action>> m_dependencies;

      std::map<Action, std::set<Action>> m_satisfiedBy;

      ScheduleNode m_schedule{{FILTER, "ROOT"}};

      std::vector<std::string> m_usedVars;

      void expandSatisfiesRelations(
          std::map<Action, std::set<Action>>::iterator itr,
          std::set<Action>& processed);
  }; //> end namespace SchedulerBase
} //> end namespace RDFAnalysis

#endif //> !RDFAnalysis_SchedulerBase_H