Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/CodeGen/ScoreboardHazardRecognizer.h
Line
Count
Source
1
//=- llvm/CodeGen/ScoreboardHazardRecognizer.h - Schedule Support -*- C++ -*-=//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
//
9
// This file defines the ScoreboardHazardRecognizer class, which
10
// encapsulates hazard-avoidance heuristics for scheduling, based on the
11
// scheduling itineraries specified for the target.
12
//
13
//===----------------------------------------------------------------------===//
14
15
#ifndef LLVM_CODEGEN_SCOREBOARDHAZARDRECOGNIZER_H
16
#define LLVM_CODEGEN_SCOREBOARDHAZARDRECOGNIZER_H
17
18
#include "llvm/CodeGen/ScheduleHazardRecognizer.h"
19
#include <cassert>
20
#include <cstddef>
21
#include <cstring>
22
23
namespace llvm {
24
25
class InstrItineraryData;
26
class ScheduleDAG;
27
class SUnit;
28
29
class ScoreboardHazardRecognizer : public ScheduleHazardRecognizer {
30
  // Scoreboard to track function unit usage. Scoreboard[0] is a
31
  // mask of the FUs in use in the cycle currently being
32
  // schedule. Scoreboard[1] is a mask for the next cycle. The
33
  // Scoreboard is used as a circular buffer with the current cycle
34
  // indicated by Head.
35
  //
36
  // Scoreboard always counts cycles in forward execution order. If used by a
37
  // bottom-up scheduler, then the scoreboard cycles are the inverse of the
38
  // scheduler's cycles.
39
  class Scoreboard {
40
    unsigned *Data = nullptr;
41
42
    // The maximum number of cycles monitored by the Scoreboard. This
43
    // value is determined based on the target itineraries to ensure
44
    // that all hazards can be tracked.
45
    size_t Depth = 0;
46
47
    // Indices into the Scoreboard that represent the current cycle.
48
    size_t Head = 0;
49
50
  public:
51
1.88M
    Scoreboard() = default;
52
53
1.88M
    ~Scoreboard() {
54
1.88M
      delete[] Data;
55
1.88M
    }
56
57
3.45M
    size_t getDepth() const { return Depth; }
58
59
10.0M
    unsigned& operator[](size_t idx) const {
60
10.0M
      // Depth is expected to be a power-of-2.
61
10.0M
      assert(Depth && !(Depth & (Depth - 1)) &&
62
10.0M
             "Scoreboard was not initialized properly!");
63
10.0M
64
10.0M
      return Data[(Head + idx) & (Depth-1)];
65
10.0M
    }
66
67
2.66M
    void reset(size_t d = 1) {
68
2.66M
      if (!Data) {
69
1.88M
        Depth = d;
70
1.88M
        Data = new unsigned[Depth];
71
1.88M
      }
72
2.66M
73
2.66M
      memset(Data, 0, Depth * sizeof(Data[0]));
74
2.66M
      Head = 0;
75
2.66M
    }
76
77
666k
    void advance() {
78
666k
      Head = (Head + 1) & (Depth-1);
79
666k
    }
80
81
1.01M
    void recede() {
82
1.01M
      Head = (Head - 1) & (Depth-1);
83
1.01M
    }
84
85
    // Print the scoreboard.
86
    void dump() const;
87
  };
88
89
  // Support for tracing ScoreboardHazardRecognizer as a component within
90
  // another module.
91
  const char *DebugType;
92
93
  // Itinerary data for the target.
94
  const InstrItineraryData *ItinData;
95
96
  const ScheduleDAG *DAG;
97
98
  /// IssueWidth - Max issue per cycle. 0=Unknown.
99
  unsigned IssueWidth = 0;
100
101
  /// IssueCount - Count instructions issued in this cycle.
102
  unsigned IssueCount = 0;
103
104
  Scoreboard ReservedScoreboard;
105
  Scoreboard RequiredScoreboard;
106
107
public:
108
  ScoreboardHazardRecognizer(const InstrItineraryData *II,
109
                             const ScheduleDAG *DAG,
110
                             const char *ParentDebugType = "");
111
112
  /// atIssueLimit - Return true if no more instructions may be issued in this
113
  /// cycle.
114
  bool atIssueLimit() const override;
115
116
  // Stalls provides an cycle offset at which SU will be scheduled. It will be
117
  // negative for bottom-up scheduling.
118
  HazardType getHazardType(SUnit *SU, int Stalls) override;
119
  void Reset() override;
120
  void EmitInstruction(SUnit *SU) override;
121
  void AdvanceCycle() override;
122
  void RecedeCycle() override;
123
};
124
125
} // end namespace llvm
126
127
#endif // LLVM_CODEGEN_SCOREBOARDHAZARDRECOGNIZER_H