Home | History | Annotate | Line # | Download | only in lib 
      1 //===-- Target.cpp ----------------------------------------------*- 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 #include "Target.h"
      9 
     10 #include "LatencyBenchmarkRunner.h"
     11 #include "ParallelSnippetGenerator.h"
     12 #include "SerialSnippetGenerator.h"
     13 #include "UopsBenchmarkRunner.h"
     14 #include "llvm/ADT/Twine.h"
     15 #include "llvm/Support/Error.h"
     16 
     17 namespace llvm {
     18 namespace exegesis {
     19 
     20 ExegesisTarget::~ExegesisTarget() {} // anchor.
     21 
     22 static ExegesisTarget *FirstTarget = nullptr;
     23 
     24 const ExegesisTarget *ExegesisTarget::lookup(Triple TT) {
     25   for (const ExegesisTarget *T = FirstTarget; T != nullptr; T = T->Next) {
     26     if (T->matchesArch(TT.getArch()))
     27       return T;
     28   }
     29   return nullptr;
     30 }
     31 
     32 Expected<std::unique_ptr<pfm::Counter>>
     33 ExegesisTarget::createCounter(StringRef CounterName, const LLVMState &) const {
     34   pfm::PerfEvent Event(CounterName);
     35   if (!Event.valid())
     36     return llvm::make_error<Failure>(
     37         llvm::Twine("Unable to create counter with name '")
     38             .concat(CounterName)
     39             .concat("'"));
     40 
     41   return std::make_unique<pfm::Counter>(std::move(Event));
     42 }
     43 
     44 void ExegesisTarget::registerTarget(ExegesisTarget *Target) {
     45   if (FirstTarget == nullptr) {
     46     FirstTarget = Target;
     47     return;
     48   }
     49   if (Target->Next != nullptr)
     50     return; // Already registered.
     51   Target->Next = FirstTarget;
     52   FirstTarget = Target;
     53 }
     54 
     55 std::unique_ptr<SnippetGenerator> ExegesisTarget::createSnippetGenerator(
     56     InstructionBenchmark::ModeE Mode, const LLVMState &State,
     57     const SnippetGenerator::Options &Opts) const {
     58   switch (Mode) {
     59   case InstructionBenchmark::Unknown:
     60     return nullptr;
     61   case InstructionBenchmark::Latency:
     62     return createSerialSnippetGenerator(State, Opts);
     63   case InstructionBenchmark::Uops:
     64   case InstructionBenchmark::InverseThroughput:
     65     return createParallelSnippetGenerator(State, Opts);
     66   }
     67   return nullptr;
     68 }
     69 
     70 Expected<std::unique_ptr<BenchmarkRunner>>
     71 ExegesisTarget::createBenchmarkRunner(
     72     InstructionBenchmark::ModeE Mode, const LLVMState &State,
     73     InstructionBenchmark::ResultAggregationModeE ResultAggMode) const {
     74   PfmCountersInfo PfmCounters = State.getPfmCounters();
     75   switch (Mode) {
     76   case InstructionBenchmark::Unknown:
     77     return nullptr;
     78   case InstructionBenchmark::Latency:
     79   case InstructionBenchmark::InverseThroughput:
     80     if (!PfmCounters.CycleCounter) {
     81       const char *ModeName = Mode == InstructionBenchmark::Latency
     82                                  ? "latency"
     83                                  : "inverse_throughput";
     84       return make_error<Failure>(
     85           Twine("can't run '")
     86               .concat(ModeName)
     87               .concat("' mode, sched model does not define a cycle counter."));
     88     }
     89     return createLatencyBenchmarkRunner(State, Mode, ResultAggMode);
     90   case InstructionBenchmark::Uops:
     91     if (!PfmCounters.UopsCounter && !PfmCounters.IssueCounters)
     92       return make_error<Failure>("can't run 'uops' mode, sched model does not "
     93                                  "define uops or issue counters.");
     94     return createUopsBenchmarkRunner(State, ResultAggMode);
     95   }
     96   return nullptr;
     97 }
     98 
     99 std::unique_ptr<SnippetGenerator> ExegesisTarget::createSerialSnippetGenerator(
    100     const LLVMState &State, const SnippetGenerator::Options &Opts) const {
    101   return std::make_unique<SerialSnippetGenerator>(State, Opts);
    102 }
    103 
    104 std::unique_ptr<SnippetGenerator> ExegesisTarget::createParallelSnippetGenerator(
    105     const LLVMState &State, const SnippetGenerator::Options &Opts) const {
    106   return std::make_unique<ParallelSnippetGenerator>(State, Opts);
    107 }
    108 
    109 std::unique_ptr<BenchmarkRunner> ExegesisTarget::createLatencyBenchmarkRunner(
    110     const LLVMState &State, InstructionBenchmark::ModeE Mode,
    111     InstructionBenchmark::ResultAggregationModeE ResultAggMode) const {
    112   return std::make_unique<LatencyBenchmarkRunner>(State, Mode, ResultAggMode);
    113 }
    114 
    115 std::unique_ptr<BenchmarkRunner> ExegesisTarget::createUopsBenchmarkRunner(
    116     const LLVMState &State,
    117     InstructionBenchmark::ResultAggregationModeE /*unused*/) const {
    118   return std::make_unique<UopsBenchmarkRunner>(State);
    119 }
    120 
    121 static_assert(std::is_pod<PfmCountersInfo>::value,
    122               "We shouldn't have dynamic initialization here");
    123 const PfmCountersInfo PfmCountersInfo::Default = {nullptr, nullptr, nullptr,
    124                                                   0u};
    125 
    126 const PfmCountersInfo &ExegesisTarget::getPfmCounters(StringRef CpuName) const {
    127   assert(llvm::is_sorted(
    128              CpuPfmCounters,
    129              [](const CpuAndPfmCounters &LHS, const CpuAndPfmCounters &RHS) {
    130                return strcmp(LHS.CpuName, RHS.CpuName) < 0;
    131              }) &&
    132          "CpuPfmCounters table is not sorted");
    133 
    134   // Find entry
    135   auto Found = llvm::lower_bound(CpuPfmCounters, CpuName);
    136   if (Found == CpuPfmCounters.end() || StringRef(Found->CpuName) != CpuName) {
    137     // Use the default.
    138     if (!CpuPfmCounters.empty() && CpuPfmCounters.begin()->CpuName[0] == '\0') {
    139       Found = CpuPfmCounters.begin(); // The target specifies a default.
    140     } else {
    141       return PfmCountersInfo::Default; // No default for the target.
    142     }
    143   }
    144   assert(Found->PCI && "Missing counters");
    145   return *Found->PCI;
    146 }
    147 
    148 ExegesisTarget::SavedState::~SavedState() {} // anchor.
    149 
    150 namespace {
    151 
    152 // Default implementation.
    153 class ExegesisDefaultTarget : public ExegesisTarget {
    154 public:
    155   ExegesisDefaultTarget() : ExegesisTarget({}) {}
    156 
    157 private:
    158   std::vector<MCInst> setRegTo(const MCSubtargetInfo &STI, unsigned Reg,
    159                                const APInt &Value) const override {
    160     llvm_unreachable("Not yet implemented");
    161   }
    162 
    163   bool matchesArch(Triple::ArchType Arch) const override {
    164     llvm_unreachable("never called");
    165     return false;
    166   }
    167 };
    168 
    169 } // namespace
    170 
    171 const ExegesisTarget &ExegesisTarget::getDefault() {
    172   static ExegesisDefaultTarget Target;
    173   return Target;
    174 }
    175 
    176 } // namespace exegesis
    177 } // namespace llvm
    178