LCOV - code coverage report
Current view: top level - include/llvm/CodeGen - LatencyPriorityQueue.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 9 19 47.4 %
Date: 2017-09-14 15:23:50 Functions: 2 8 25.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===---- LatencyPriorityQueue.h - A latency-oriented priority queue ------===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : // This file declares the LatencyPriorityQueue class, which is a
      11             : // SchedulingPriorityQueue that schedules using latency information to
      12             : // reduce the length of the critical path through the basic block.
      13             : //
      14             : //===----------------------------------------------------------------------===//
      15             : 
      16             : #ifndef LLVM_CODEGEN_LATENCYPRIORITYQUEUE_H
      17             : #define LLVM_CODEGEN_LATENCYPRIORITYQUEUE_H
      18             : 
      19             : #include "llvm/CodeGen/ScheduleDAG.h"
      20             : 
      21             : namespace llvm {
      22             :   class LatencyPriorityQueue;
      23             : 
      24             :   /// Sorting functions for the Available queue.
      25             :   struct latency_sort : public std::binary_function<SUnit*, SUnit*, bool> {
      26             :     LatencyPriorityQueue *PQ;
      27       32522 :     explicit latency_sort(LatencyPriorityQueue *pq) : PQ(pq) {}
      28             : 
      29             :     bool operator()(const SUnit* left, const SUnit* right) const;
      30             :   };
      31             : 
      32       97566 :   class LatencyPriorityQueue : public SchedulingPriorityQueue {
      33             :     // SUnits - The SUnits for the current graph.
      34             :     std::vector<SUnit> *SUnits;
      35             : 
      36             :     /// NumNodesSolelyBlocking - This vector contains, for every node in the
      37             :     /// Queue, the number of nodes that the node is the sole unscheduled
      38             :     /// predecessor for.  This is used as a tie-breaker heuristic for better
      39             :     /// mobility.
      40             :     std::vector<unsigned> NumNodesSolelyBlocking;
      41             : 
      42             :     /// Queue - The queue.
      43             :     std::vector<SUnit*> Queue;
      44             :     latency_sort Picker;
      45             : 
      46             :   public:
      47      162610 :     LatencyPriorityQueue() : Picker(this) {
      48             :     }
      49             : 
      50           0 :     bool isBottomUp() const override { return false; }
      51             : 
      52           0 :     void initNodes(std::vector<SUnit> &sunits) override {
      53      610624 :       SUnits = &sunits;
      54     1221248 :       NumNodesSolelyBlocking.resize(SUnits->size(), 0);
      55           0 :     }
      56             : 
      57           0 :     void addNode(const SUnit *SU) override {
      58           0 :       NumNodesSolelyBlocking.resize(SUnits->size(), 0);
      59           0 :     }
      60             : 
      61           0 :     void updateNode(const SUnit *SU) override {
      62           0 :     }
      63             : 
      64           0 :     void releaseState() override {
      65      610624 :       SUnits = nullptr;
      66           0 :     }
      67             : 
      68             :     unsigned getLatency(unsigned NodeNum) const {
      69             :       assert(NodeNum < (*SUnits).size());
      70    24686124 :       return (*SUnits)[NodeNum].getHeight();
      71             :     }
      72             : 
      73             :     unsigned getNumSolelyBlockNodes(unsigned NodeNum) const {
      74             :       assert(NodeNum < NumNodesSolelyBlocking.size());
      75    13590280 :       return NumNodesSolelyBlocking[NodeNum];
      76             :     }
      77             : 
      78    10310988 :     bool empty() const override { return Queue.empty(); }
      79             : 
      80             :     void push(SUnit *U) override;
      81             : 
      82             :     SUnit *pop() override;
      83             : 
      84             :     void remove(SUnit *SU) override;
      85             : 
      86             :     // scheduledNode - As nodes are scheduled, we look to see if there are any
      87             :     // successor nodes that have a single unscheduled predecessor.  If so, that
      88             :     // single predecessor has a higher priority, since scheduling it will make
      89             :     // the node available.
      90             :     void scheduledNode(SUnit *Node) override;
      91             : 
      92             : private:
      93             :     void AdjustPriorityOfUnscheduledPreds(SUnit *SU);
      94             :     SUnit *getSingleUnscheduledPred(SUnit *SU);
      95             :   };
      96             : }
      97             : 
      98             : #endif

Generated by: LCOV version 1.13