Coverage Report

Created: 2017-10-03 07:32

/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/include/llvm/CodeGen/LatencyPriorityQueue.h
Line
Count
Source (jump to first uncovered line)
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 {
26
    LatencyPriorityQueue *PQ;
27
33.9k
    explicit latency_sort(LatencyPriorityQueue *pq) : PQ(pq) {}
28
29
    bool operator()(const SUnit* left, const SUnit* right) const;
30
  };
31
32
  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
33.9k
    LatencyPriorityQueue() : Picker(this) {
48
33.9k
    }
49
50
0
    bool isBottomUp() const override { return false; }
51
52
185k
    void initNodes(std::vector<SUnit> &sunits) override {
53
185k
      SUnits = &sunits;
54
185k
      NumNodesSolelyBlocking.resize(SUnits->size(), 0);
55
185k
    }
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
185k
    void releaseState() override {
65
185k
      SUnits = nullptr;
66
185k
    }
67
68
2.28M
    unsigned getLatency(unsigned NodeNum) const {
69
2.28M
      assert(NodeNum < (*SUnits).size());
70
2.28M
      return (*SUnits)[NodeNum].getHeight();
71
2.28M
    }
72
73
1.33M
    unsigned getNumSolelyBlockNodes(unsigned NodeNum) const {
74
1.33M
      assert(NodeNum < NumNodesSolelyBlocking.size());
75
1.33M
      return NumNodesSolelyBlocking[NodeNum];
76
1.33M
    }
77
78
2.86M
    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