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