1 | //===--------------------- Support.h ----------------------------*- 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 | /// \file |
9 | /// |
10 | /// Helper functions used by various pipeline components. |
11 | /// |
12 | //===----------------------------------------------------------------------===// |
13 | |
14 | #ifndef LLVM_MCA_SUPPORT_H |
15 | #define LLVM_MCA_SUPPORT_H |
16 | |
17 | #include "llvm/ADT/ArrayRef.h" |
18 | #include "llvm/ADT/SmallVector.h" |
19 | #include "llvm/MC/MCSchedule.h" |
20 | #include "llvm/Support/Error.h" |
21 | #include "llvm/Support/MathExtras.h" |
22 | |
23 | namespace llvm { |
24 | namespace mca { |
25 | |
26 | template <typename T> |
27 | class InstructionError : public ErrorInfo<InstructionError<T>> { |
28 | public: |
29 | static char ID; |
30 | std::string Message; |
31 | const T &Inst; |
32 | |
33 | InstructionError(std::string M, const T &MCI) |
34 | : Message(std::move(M)), Inst(MCI) {} |
35 | |
36 | void log(raw_ostream &OS) const override { OS << Message; } |
37 | |
38 | std::error_code convertToErrorCode() const override { |
39 | return inconvertibleErrorCode(); |
40 | } |
41 | }; |
42 | |
43 | template <typename T> char InstructionError<T>::ID; |
44 | |
45 | /// This class represents the number of cycles per resource (fractions of |
46 | /// cycles). That quantity is managed here as a ratio, and accessed via the |
47 | /// double cast-operator below. The two quantities, number of cycles and |
48 | /// number of resources, are kept separate. This is used by the |
49 | /// ResourcePressureView to calculate the average resource cycles |
50 | /// per instruction/iteration. |
51 | class ReleaseAtCycles { |
52 | unsigned Numerator, Denominator; |
53 | |
54 | public: |
55 | ReleaseAtCycles() : Numerator(0), Denominator(1) {} |
56 | ReleaseAtCycles(unsigned Cycles, unsigned ResourceUnits = 1) |
57 | : Numerator(Cycles), Denominator(ResourceUnits) {} |
58 | |
59 | operator double() const { |
60 | assert(Denominator && "Invalid denominator (must be non-zero)." ); |
61 | return (Denominator == 1) ? Numerator : (double)Numerator / Denominator; |
62 | } |
63 | |
64 | unsigned getNumerator() const { return Numerator; } |
65 | unsigned getDenominator() const { return Denominator; } |
66 | |
67 | // Add the components of RHS to this instance. Instead of calculating |
68 | // the final value here, we keep track of the numerator and denominator |
69 | // separately, to reduce floating point error. |
70 | ReleaseAtCycles &operator+=(const ReleaseAtCycles &RHS); |
71 | }; |
72 | |
73 | /// Populates vector Masks with processor resource masks. |
74 | /// |
75 | /// The number of bits set in a mask depends on the processor resource type. |
76 | /// Each processor resource mask has at least one bit set. For groups, the |
77 | /// number of bits set in the mask is equal to the cardinality of the group plus |
78 | /// one. Excluding the most significant bit, the remaining bits in the mask |
79 | /// identify processor resources that are part of the group. |
80 | /// |
81 | /// Example: |
82 | /// |
83 | /// ResourceA -- Mask: 0b001 |
84 | /// ResourceB -- Mask: 0b010 |
85 | /// ResourceAB -- Mask: 0b100 U (ResourceA::Mask | ResourceB::Mask) == 0b111 |
86 | /// |
87 | /// ResourceAB is a processor resource group containing ResourceA and ResourceB. |
88 | /// Each resource mask uniquely identifies a resource; both ResourceA and |
89 | /// ResourceB only have one bit set. |
90 | /// ResourceAB is a group; excluding the most significant bit in the mask, the |
91 | /// remaining bits identify the composition of the group. |
92 | /// |
93 | /// Resource masks are used by the ResourceManager to solve set membership |
94 | /// problems with simple bit manipulation operations. |
95 | void computeProcResourceMasks(const MCSchedModel &SM, |
96 | MutableArrayRef<uint64_t> Masks); |
97 | |
98 | // Returns the index of the highest bit set. For resource masks, the position of |
99 | // the highest bit set can be used to construct a resource mask identifier. |
100 | inline unsigned getResourceStateIndex(uint64_t Mask) { |
101 | assert(Mask && "Processor Resource Mask cannot be zero!" ); |
102 | return llvm::Log2_64(Value: Mask); |
103 | } |
104 | |
105 | /// Compute the reciprocal block throughput from a set of processor resource |
106 | /// cycles. The reciprocal block throughput is computed as the MAX between: |
107 | /// - NumMicroOps / DispatchWidth |
108 | /// - ProcReleaseAtCycles / #ProcResourceUnits (for every consumed resource). |
109 | double computeBlockRThroughput(const MCSchedModel &SM, unsigned DispatchWidth, |
110 | unsigned NumMicroOps, |
111 | ArrayRef<unsigned> ProcResourceUsage); |
112 | } // namespace mca |
113 | } // namespace llvm |
114 | |
115 | #endif // LLVM_MCA_SUPPORT_H |
116 | |