llvm/tools/llvm-exegesis/lib/SnippetRepetitor.cpp

   1 //===-- SnippetRepetitor.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
   9 #include <array>
  10 #include <string>
  11
  12 #include "SnippetRepetitor.h"
  13 #include "Target.h"
  14 #include "llvm/ADT/Sequence.h"
  15 #include "llvm/CodeGen/TargetInstrInfo.h"
  16 #include "llvm/CodeGen/TargetSubtargetInfo.h"
  17
  18 namespace llvm {
  19 namespace exegesis {
  20 namespace {
  21
  22 class DuplicateSnippetRepetitor : public SnippetRepetitor {
  23 public:
  24   using SnippetRepetitor::SnippetRepetitor;
  25
  26   // Repeats the snippet until there are at least MinInstructions in the
  27   // resulting code.
  28   FillFunction Repeat(ArrayRef<MCInst> Instructions, unsigned MinInstructions,
  29                       unsigned LoopBodySize) const override {
  30     return [Instructions, MinInstructions](FunctionFiller &Filler) {
  31       auto Entry = Filler.getEntry();
  32       if (!Instructions.empty()) {
  33         // Add the whole snippet at least once.
  34         Entry.addInstructions(Instructions);
  35         for (unsigned I = Instructions.size(); I < MinInstructions; ++I) {
  36           Entry.addInstruction(Instructions[I % Instructions.size()]);
  37         }
  38       }
  39       Entry.addReturn();
  40     };
  41   }
  42
  43   BitVector getReservedRegs() const override {
  44     // We're using no additional registers.
  45     return State.getRATC().emptyRegisters();
  46   }
  47 };
  48
  49 class LoopSnippetRepetitor : public SnippetRepetitor {
  50 public:
  51   explicit LoopSnippetRepetitor(const LLVMState &State)
  52       : SnippetRepetitor(State),
  53         LoopCounter(State.getExegesisTarget().getLoopCounterRegister(
  54             State.getTargetMachine().getTargetTriple())) {}
  55
  56   // Loop over the snippet ceil(MinInstructions / Instructions.Size()) times.
  57   FillFunction Repeat(ArrayRef<MCInst> Instructions, unsigned MinInstructions,
  58                       unsigned LoopBodySize) const override {
  59     return [this, Instructions, MinInstructions,
  60             LoopBodySize](FunctionFiller &Filler) {
  61       const auto &ET = State.getExegesisTarget();
  62       auto Entry = Filler.getEntry();
  63       auto Loop = Filler.addBasicBlock();
  64       auto Exit = Filler.addBasicBlock();
  65
  66       const unsigned LoopUnrollFactor =
  67           LoopBodySize <= Instructions.size()
  68               ? 1
  69               : divideCeil(LoopBodySize, Instructions.size());
  70       assert(LoopUnrollFactor >= 1 && "Should end up with at least 1 snippet.");
  71
  72       // Set loop counter to the right value:
  73       const APInt LoopCount(
  74           32,
  75           divideCeil(MinInstructions, LoopUnrollFactor * Instructions.size()));
  76       assert(LoopCount.uge(1) && "Trip count should be at least 1.");
  77       for (const MCInst &Inst :
  78            ET.setRegTo(State.getSubtargetInfo(), LoopCounter, LoopCount))
  79         Entry.addInstruction(Inst);
  80
  81       // Set up the loop basic block.
  82       Entry.MBB->addSuccessor(Loop.MBB, BranchProbability::getOne());
  83       Loop.MBB->addSuccessor(Loop.MBB, BranchProbability::getOne());
  84       // The live ins are: the loop counter, the registers that were setup by
  85       // the entry block, and entry block live ins.
  86       Loop.MBB->addLiveIn(LoopCounter);
  87       for (unsigned Reg : Filler.getRegistersSetUp())
  88         Loop.MBB->addLiveIn(Reg);
  89       for (const auto &LiveIn : Entry.MBB->liveins())
  90         Loop.MBB->addLiveIn(LiveIn);
  91       for (auto _ : seq(0U, LoopUnrollFactor)) {
  92         (void)_;
  93         Loop.addInstructions(Instructions);
  94       }
  95       ET.decrementLoopCounterAndJump(*Loop.MBB, *Loop.MBB,
  96                                      State.getInstrInfo());
  97
  98       // Set up the exit basic block.
  99       Loop.MBB->addSuccessor(Exit.MBB, BranchProbability::getZero());
 100       Exit.addReturn();
 101     };
 102   }
 103
 104   BitVector getReservedRegs() const override {
 105     // We're using a single loop counter, but we have to reserve all aliasing
 106     // registers.
 107     return State.getRATC().getRegister(LoopCounter).aliasedBits();
 108   }
 109
 110 private:
 111   const unsigned LoopCounter;
 112 };
 113
 114 } // namespace
 115
 116 SnippetRepetitor::~SnippetRepetitor() {}
 117
 118 std::unique_ptr<const SnippetRepetitor>
 119 SnippetRepetitor::Create(InstructionBenchmark::RepetitionModeE Mode,
 120                          const LLVMState &State) {
 121   switch (Mode) {
 122   case InstructionBenchmark::Duplicate:
 123     return std::make_unique<DuplicateSnippetRepetitor>(State);
 124   case InstructionBenchmark::Loop:
 125     return std::make_unique<LoopSnippetRepetitor>(State);
 126   case InstructionBenchmark::AggregateMin:
 127     break;
 128   }
 129   llvm_unreachable("Unknown RepetitionModeE enum");
 130 }
 131
 132 } // namespace exegesis
 133 } // namespace llvm