Merge pull request #148 from Quincunx271/feature-occupancy-preserving-ilp-gt

Combined ILP & RP Graph Transformations

Author: Quincunx271

example/optsched-cfg/sched.ini

@@ -95,6 +95,10 @@ SECOND_PASS_LENGTH_TIMEOUT 5
 # BLOCK : use the time limits in the above fields as is
 TIMEOUT_PER INSTR
 
+# The maximum number of instructions to use the scheduler for.
+# Beyond this size, the heuristic scheduler is used.
+MAX_REGION_LENGTH 2147483647
+
 # The heuristic used for the list scheduler. Valid values are any combination of:
 # CP: critical path
 # LUC: last use count
@@ -243,9 +247,29 @@ REGIONS_TO_SCHEDULE fft1D_512:114
 # history domination is disabled.
 ENABLE_SUFFIX_CONCATENATION NO
 
+# Where to perform graph transformations. Valid values are any combination of:
+# BH - before heuristic; run on all blocks that we schedule
+# AH - after heuristic; only if the heuristic scheduler doesn't prove optimality
+GT_POSITION AH
+
+# Where to perform graph transformations for the second pass.
+# Valid values are the same as with GT_POSITION.
+# However, note that the sequential list scheduler is practically never
+# going to give an optimal schedule, so BH is almost certainly superior.
+2ND_PASS_GT_POSITION BH
+
 # Whether to apply the node superiority graph transformation.
 STATIC_NODE_SUPERIORITY NO
 
+# Whether to apply the ILP only node superiority graph transformation.
+STATIC_NODE_SUPERIORITY_ILP NO
+
+# Whether to apply the combined node superiority graph transformation.
+STATIC_NODE_SUPERIORITY_ILP_PRESERVE_OCCUPANCY NO
+
+# Whether the second pass of the two pass algorithm should use the combined node superiority graph transformation.
+2ND_PASS_ILP_NODE_SUPERIORITY_PRESERVING_OCCUPANCY NO
+
 # Whether to apply node superiority in multiple passes.
 MULTI_PASS_NODE_SUPERIORITY NO
 

include/opt-sched/Scheduler/bb_spill.h

@@ -118,7 +118,7 @@ class BBWithSpill : public SchedRegion {
               SchedPriorities hurstcPrirts, SchedPriorities enumPrirts,
               bool vrfySched, Pruning PruningStrategy, bool SchedForRPOnly,
               bool enblStallEnum, int SCW, SPILL_COST_FUNCTION spillCostFunc,
-              SchedulerType HeurSchedType);
+              SchedulerType HeurSchedType, GT_POSITION GraphTransPosition);
   ~BBWithSpill();
 
   InstCount CmputExecCostLwrBound();

include/opt-sched/Scheduler/graph_trans.h

@@ -91,6 +91,13 @@ class StaticNodeSupTrans : public GraphTrans {
 
   static bool isNodeSuperior(DataDepGraph &DDG, int A, int B);
 
+  struct Statistics {
+    int NumEdgesAdded = 0;
+    int NumEdgesRemoved = 0;
+  };
+  static void removeRedundantEdges(DataDepGraph &DDG, int i, int j,
+                                   Statistics &Stats);
+
 private:
   // Are multiple passes enabled.
   bool IsMultiPass;
@@ -103,8 +110,9 @@ class StaticNodeSupTrans : public GraphTrans {
 
   // Check if there is superiority involving nodes A and B. If yes, choose which
   // edge to add.
-  // Returns true if a superior edge was added.
-  bool TryAddingSuperiorEdge_(SchedInstruction *nodeA, SchedInstruction *nodeB);
+  // Returns the added edge if added, else nullptr
+  GraphEdge *TryAddingSuperiorEdge_(SchedInstruction *nodeA,
+                                    SchedInstruction *nodeB);
 
   // Keep trying to find superior nodes until none can be found or there are no
   // more independent nodes.

include/opt-sched/Scheduler/graph_trans_ilp_occupancy_preserving.h

@@ -0,0 +1,31 @@
+/*******************************************************************************
+Description:  Implement graph transformations to be applied before scheduling.
+Author:       Justin Bassett
+Created:      Aug. 2020
+Last Update:  Aug. 2020
+*******************************************************************************/
+
+#ifndef OPTSCHED_BASIC_GRAPH_TRANS_ILP_OCCUPANCY_PRESERVING_H
+#define OPTSCHED_BASIC_GRAPH_TRANS_ILP_OCCUPANCY_PRESERVING_H
+
+#include "opt-sched/Scheduler/graph_trans.h"
+
+namespace llvm {
+namespace opt_sched {
+
+// Node superiority Occupancy preserving ILP graph transformation.
+class StaticNodeSupOccupancyPreservingILPTrans : public GraphTrans {
+public:
+  StaticNodeSupOccupancyPreservingILPTrans(DataDepGraph *dataDepGraph);
+
+  const char *Name() const override {
+    return "occupancy-preserving-ilp.nodesup";
+  }
+
+  FUNC_RESULT ApplyTrans() override;
+};
+
+} // namespace opt_sched
+} // namespace llvm
+
+#endif

include/opt-sched/Scheduler/ready_list.h

@@ -86,6 +86,13 @@ class ReadyList {
   // Constructs the priority-list key based on the schemes listed in prirts_.
   unsigned long CmputKey_(SchedInstruction *inst, bool isUpdate, bool &changed);
 
+  template <typename InstructionVisitor>
+  void ForEachReadyInstruction(InstructionVisitor &&visitor) const {
+    for (const SchedInstruction &Inst : prirtyLst_) {
+      visitor(Inst);
+    }
+  }
+
 private:
   // An ordered vector of priorities
   SchedPriorities prirts_;

include/opt-sched/Scheduler/register.h

@@ -13,6 +13,7 @@ Last Update:  Jun. 2017
 #include "opt-sched/Scheduler/sched_basic_data.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/iterator.h"
 #include <memory>
 
 using namespace llvm;
@@ -87,6 +88,8 @@ class Register {
   bool IsInPossibleInterval(const SchedInstruction *inst) const;
   const InstSetType &GetPossibleLiveInterval() const;
 
+  void resetLiveInterval();
+
 private:
   int16_t type_;
   int num_;
@@ -124,10 +127,75 @@ class Register {
 
 // Represents a file of registers of a certain type and tracks their usages.
 class RegisterFile {
+  template <bool IsConst, typename R = typename std::conditional<
+                              IsConst, const Register, Register>::type>
+  class RegisterFileIterator
+      : public llvm::iterator_facade_base<RegisterFileIterator<IsConst>,
+                                          std::random_access_iterator_tag, R> {
+
+  public:
+    RegisterFileIterator() = default;
+    explicit RegisterFileIterator(const RegisterFile &File, int Index)
+        : File(&File), Index(Index) {}
+
+    template <bool IsConst_ = IsConst,
+              typename std::enable_if<IsConst_, int>::type = 0>
+    RegisterFileIterator(const RegisterFileIterator<false> &Rhs) noexcept
+        : File(Rhs.File), Index(Rhs.Index) {}
+
+    bool operator==(const RegisterFileIterator &Rhs) const {
+      assert(File == Rhs.File);
+      return Index == Rhs.Index;
+    }
+
+    bool operator<(const RegisterFileIterator &Rhs) const {
+      assert(File == Rhs.File);
+      return Index < Rhs.Index;
+    }
+
+    std::ptrdiff_t operator-(const RegisterFileIterator &Rhs) const {
+      return Index - Rhs.Index;
+    }
+
+    R &operator*() const { return *File->GetReg(Index); }
+
+    RegisterFileIterator &operator++() {
+      ++Index;
+      return *this;
+    }
+
+    RegisterFileIterator &operator--() {
+      --Index;
+      return *this;
+    }
+
+    RegisterFileIterator &operator+=(std::ptrdiff_t n) {
+      Index += n;
+      return *this;
+    }
+
+    RegisterFileIterator &operator-=(std::ptrdiff_t n) {
+      Index -= n;
+      return *this;
+    }
+
+  private:
+    const RegisterFile *File = nullptr;
+    int Index = 0;
+  };
+
 public:
+  using iterator = RegisterFileIterator<false>;
+  using const_iterator = RegisterFileIterator<true>;
+
   RegisterFile();
   ~RegisterFile();
 
+  iterator begin() { return iterator(*this, 0); }
+  iterator end() { return iterator(*this, GetRegCnt()); }
+  const_iterator begin() const { return const_iterator(*this, 0); }
+  const_iterator end() const { return const_iterator(*this, GetRegCnt()); }
+
   int GetRegCnt() const;
   void SetRegCnt(int regCnt);
 
@@ -157,7 +225,7 @@ class RegisterFile {
 private:
   int16_t regType_;
   int physRegCnt_;
-  mutable SmallVector<std::unique_ptr<Register>, 8> Regs;
+  SmallVector<std::unique_ptr<Register>, 8> Regs;
 };
 
 } // namespace opt_sched

include/opt-sched/Scheduler/sched_basic_data.h

@@ -425,9 +425,9 @@ class SchedInstruction : public GraphNode {
   void ComputeAdjustedUseCnt(SchedInstruction *inst);
 
   int16_t CmputLastUseCnt();
-  int16_t GetLastUseCnt() { return lastUseCnt_; }
+  int16_t GetLastUseCnt() const { return lastUseCnt_; }
 
-  InstType GetCrtclPathFrmRoot() { return crtclPathFrmRoot_; }
+  InstType GetCrtclPathFrmRoot() const { return crtclPathFrmRoot_; }
 
   friend class SchedRange;
 

include/opt-sched/Scheduler/sched_region.h

@@ -39,6 +39,31 @@ enum class BLOCKS_TO_KEEP {
   ALL
 };
 
+// Where to perform graph transformations; flag enum
+enum class GT_POSITION : uint32_t {
+  NONE = 0x0,
+  // Run on all blocks before the heuristic
+  BEFORE_HEURISTIC = 0x1,
+  // Run only if the heuristic scheduler doesn't prove the schedule optimal
+  AFTER_HEURISTIC = 0x2,
+};
+
+inline GT_POSITION operator|(GT_POSITION lhs, GT_POSITION rhs) {
+  return (GT_POSITION)((uint32_t)lhs | (uint32_t)rhs);
+}
+
+inline GT_POSITION operator&(GT_POSITION lhs, GT_POSITION rhs) {
+  return (GT_POSITION)((uint32_t)lhs & (uint32_t)rhs);
+}
+
+inline GT_POSITION &operator|=(GT_POSITION &lhs, GT_POSITION rhs) {
+  return lhs = lhs | rhs;
+}
+
+inline GT_POSITION &operator&=(GT_POSITION &lhs, GT_POSITION rhs) {
+  return lhs = lhs & rhs;
+}
+
 class ListScheduler;
 
 class SchedRegion {
@@ -48,7 +73,8 @@ class SchedRegion {
               int16_t sigHashSize, LB_ALG lbAlg, SchedPriorities hurstcPrirts,
               SchedPriorities enumPrirts, bool vrfySched,
               Pruning PruningStrategy, SchedulerType HeurSchedType,
-              SPILL_COST_FUNCTION spillCostFunc = SCF_PERP);
+              SPILL_COST_FUNCTION spillCostFunc,
+              GT_POSITION GraphTransPosition);
   // Destroys the region. Must be overriden by child classes.
   virtual ~SchedRegion() {}
 
@@ -205,6 +231,9 @@ class SchedRegion {
   // TODO(max): Document.
   int16_t sigHashSize_;
 
+  // Where to apply graph transformations
+  GT_POSITION GraphTransPosition_;
+
   // The pruning technique to use for this region.
   Pruning prune_;
 
@@ -224,6 +253,11 @@ class SchedRegion {
   // The best schedule found so far (may be heuristic or enumerator generated)
   InstSchedule *bestSched_;
 
+  void CalculateUpperBounds(bool BbSchedulerEnabled);
+  void CalculateLowerBounds(bool BbSchedulerEnabled);
+
+  bool IsLowerBoundSet_ = false;
+  bool IsUpperBoundSet_ = false;
   // TODO(max): Document.
   InstCount schedLwrBound_;
   // TODO(max): Document.
@@ -244,6 +278,8 @@ class SchedRegion {
   // TODO(max): Document.
   InstCount crntSlotNum_;
 
+  bool needsTransitiveClosure(Milliseconds rgnTimeout) const;
+
   // protected accessors:
   SchedulerType GetHeuristicSchedulerType() const { return HeurSchedType_; }
 
@@ -324,6 +360,13 @@ class SchedRegion {
 
   FUNC_RESULT runACO(InstSchedule *ReturnSched, InstSchedule *InitSched,
                      bool IsPostBB);
+
+  FUNC_RESULT applyGraphTransformations(bool BbScheduleEnabled,
+                                        InstSchedule *heuristicSched,
+                                        bool &isLstOptml,
+                                        InstSchedule *&bestSched);
+  FUNC_RESULT applyGraphTransformation(GraphTrans *GT);
+  void updateBoundsAfterGraphTransformations(bool BbSchedulerEnabled);
 };
 
 } // namespace opt_sched

include/opt-sched/Scheduler/utilities.h

@@ -22,7 +22,14 @@ uint16_t clcltBitsNeededToHoldNum(uint64_t value);
 Milliseconds GetProcessorTime();
 // Returns a reference to an object that is supposed to initialized with the
 // start time of the process
-extern std::chrono::high_resolution_clock::time_point startTime;
+extern std::chrono::steady_clock::time_point startTime;
+
+// Executes the function, returning the number of milliseconds it took to do so.
+template <typename F> Milliseconds countMillisToExecute(F &&fn) {
+  const Milliseconds Start = GetProcessorTime();
+  fn();
+  return GetProcessorTime() - Start;
+}
 } // namespace Utilities
 
 inline uint16_t Utilities::clcltBitsNeededToHoldNum(uint64_t value) {
@@ -36,7 +43,7 @@ inline uint16_t Utilities::clcltBitsNeededToHoldNum(uint64_t value) {
 }
 
 inline Milliseconds Utilities::GetProcessorTime() {
-  auto currentTime = std::chrono::high_resolution_clock::now();
+  auto currentTime = std::chrono::steady_clock::now();
   std::chrono::duration<double, std::milli> elapsed = currentTime - startTime;
   return elapsed.count();
 }

lib/CMakeLists.txt

@@ -8,6 +8,7 @@ set(OPTSCHED_SRCS Scheduler/aco.cpp
   Scheduler/graph.cpp
   Scheduler/graph_trans.cpp
   Scheduler/graph_trans_ilp.cpp
+  Scheduler/graph_trans_ilp_occupancy_preserving.cpp
   Scheduler/hist_table.cpp
   Scheduler/list_sched.cpp
   Scheduler/logger.cpp