llvm/tools/llvm-exegesis/lib/BenchmarkResult.h

   1 //===-- BenchmarkResult.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 ///
   9 /// \file
  10 /// Defines classes to represent measurements and serialize/deserialize them to
  11 //  Yaml.
  12 ///
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_TOOLS_LLVM_EXEGESIS_BENCHMARKRESULT_H
  16 #define LLVM_TOOLS_LLVM_EXEGESIS_BENCHMARKRESULT_H
  17
  18 #include "LlvmState.h"
  19 #include "RegisterValue.h"
  20 #include "llvm/ADT/StringMap.h"
  21 #include "llvm/ADT/StringRef.h"
  22 #include "llvm/MC/MCInst.h"
  23 #include "llvm/MC/MCInstBuilder.h"
  24 #include "llvm/Support/YAMLTraits.h"
  25 #include <limits>
  26 #include <string>
  27 #include <unordered_map>
  28 #include <vector>
  29
  30 namespace llvm {
  31 class Error;
  32
  33 namespace exegesis {
  34
  35 struct InstructionBenchmarkKey {
  36   // The LLVM opcode name.
  37   std::vector<MCInst> Instructions;
  38   // The initial values of the registers.
  39   std::vector<RegisterValue> RegisterInitialValues;
  40   // An opaque configuration, that can be used to separate several benchmarks of
  41   // the same instruction under different configurations.
  42   std::string Config;
  43 };
  44
  45 struct BenchmarkMeasure {
  46   // A helper to create an unscaled BenchmarkMeasure.
  47   static BenchmarkMeasure Create(std::string Key, double Value) {
  48     return {Key, Value, Value};
  49   }
  50   std::string Key;
  51   // This is the per-instruction value, i.e. measured quantity scaled per
  52   // instruction.
  53   double PerInstructionValue;
  54   // This is the per-snippet value, i.e. measured quantity for one repetition of
  55   // the whole snippet.
  56   double PerSnippetValue;
  57 };
  58
  59 // The result of an instruction benchmark.
  60 struct InstructionBenchmark {
  61   InstructionBenchmarkKey Key;
  62   enum ModeE { Unknown, Latency, Uops, InverseThroughput };
  63   ModeE Mode;
  64   std::string CpuName;
  65   std::string LLVMTriple;
  66   // Which instruction is being benchmarked here?
  67   const MCInst &keyInstruction() const { return Key.Instructions[0]; }
  68   // The number of instructions inside the repeated snippet. For example, if a
  69   // snippet of 3 instructions is repeated 4 times, this is 12.
  70   unsigned NumRepetitions = 0;
  71   enum RepetitionModeE { Duplicate, Loop, AggregateMin };
  72   // Note that measurements are per instruction.
  73   std::vector<BenchmarkMeasure> Measurements;
  74   std::string Error;
  75   std::string Info;
  76   std::vector<uint8_t> AssembledSnippet;
  77   // How to aggregate measurements.
  78   enum ResultAggregationModeE { Min, Max, Mean, MinVariance };
  79   // Read functions.
  80   static Expected<InstructionBenchmark> readYaml(const LLVMState &State,
  81                                                  StringRef Filename);
  82
  83   static Expected<std::vector<InstructionBenchmark>>
  84   readYamls(const LLVMState &State, StringRef Filename);
  85
  86   class Error readYamlFrom(const LLVMState &State, StringRef InputContent);
  87
  88   // Write functions, non-const because of YAML traits.
  89   class Error writeYamlTo(const LLVMState &State, raw_ostream &S);
  90
  91   class Error writeYaml(const LLVMState &State, const StringRef Filename);
  92 };
  93
  94 bool operator==(const BenchmarkMeasure &A, const BenchmarkMeasure &B);
  95
  96 //------------------------------------------------------------------------------
  97 // Utilities to work with Benchmark measures.
  98
  99 // A class that measures stats over benchmark measures.
 100 class PerInstructionStats {
 101 public:
 102   void push(const BenchmarkMeasure &BM);
 103
 104   double avg() const {
 105     assert(NumValues);
 106     return SumValues / NumValues;
 107   }
 108   double min() const { return MinValue; }
 109   double max() const { return MaxValue; }
 110
 111   const std::string &key() const { return Key; }
 112
 113 private:
 114   std::string Key;
 115   double SumValues = 0.0;
 116   int NumValues = 0;
 117   double MaxValue = std::numeric_limits<double>::min();
 118   double MinValue = std::numeric_limits<double>::max();
 119 };
 120
 121 } // namespace exegesis
 122 } // namespace llvm
 123
 124 #endif // LLVM_TOOLS_LLVM_EXEGESIS_BENCHMARKRESULT_H