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

   1 //===-- PerfHelper.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 "PerfHelper.h"
  10 #include "llvm/Config/config.h"
  11 #include "llvm/Support/Errc.h"
  12 #include "llvm/Support/Error.h"
  13 #include "llvm/Support/raw_ostream.h"
  14 #ifdef HAVE_LIBPFM
  15 #include <perfmon/perf_event.h>
  16 #include <perfmon/pfmlib.h>
  17 #include <perfmon/pfmlib_perf_event.h>
  18 #endif
  19
  20 #include <cassert>
  21 #include <cstddef>
  22 #include <errno.h>  // for erno
  23 #include <string.h> // for strerror()
  24
  25 namespace llvm {
  26 namespace exegesis {
  27 namespace pfm {
  28
  29 #ifdef HAVE_LIBPFM
  30 static bool isPfmError(int Code) { return Code != PFM_SUCCESS; }
  31 #endif
  32
  33 bool pfmInitialize() {
  34 #ifdef HAVE_LIBPFM
  35   return isPfmError(pfm_initialize());
  36 #else
  37   return true;
  38 #endif
  39 }
  40
  41 void pfmTerminate() {
  42 #ifdef HAVE_LIBPFM
  43   pfm_terminate();
  44 #endif
  45 }
  46
  47 // Performance counters may be unavailable for a number of reasons (such as
  48 // kernel.perf_event_paranoid restriction or CPU being unknown to libpfm).
  49 //
  50 // Dummy event can be specified to skip interaction with real performance
  51 // counters while still passing control to the generated code snippet.
  52 const char *const PerfEvent::DummyEventString = "not-really-an-event";
  53
  54 PerfEvent::~PerfEvent() {
  55 #ifdef HAVE_LIBPFM
  56   delete Attr;
  57   ;
  58 #endif
  59 }
  60
  61 PerfEvent::PerfEvent(PerfEvent &&Other)
  62     : EventString(std::move(Other.EventString)),
  63       FullQualifiedEventString(std::move(Other.FullQualifiedEventString)),
  64       Attr(Other.Attr) {
  65   Other.Attr = nullptr;
  66 }
  67
  68 PerfEvent::PerfEvent(StringRef PfmEventString)
  69     : EventString(PfmEventString.str()), Attr(nullptr) {
  70   if (PfmEventString != DummyEventString)
  71     initRealEvent(PfmEventString);
  72   else
  73     FullQualifiedEventString = PfmEventString;
  74 }
  75
  76 void PerfEvent::initRealEvent(StringRef PfmEventString) {
  77 #ifdef HAVE_LIBPFM
  78   char *Fstr = nullptr;
  79   pfm_perf_encode_arg_t Arg = {};
  80   Attr = new perf_event_attr();
  81   Arg.attr = Attr;
  82   Arg.fstr = &Fstr;
  83   Arg.size = sizeof(pfm_perf_encode_arg_t);
  84   const int Result = pfm_get_os_event_encoding(EventString.c_str(), PFM_PLM3,
  85                                                PFM_OS_PERF_EVENT, &Arg);
  86   if (isPfmError(Result)) {
  87     // We don't know beforehand which counters are available (e.g. 6 uops ports
  88     // on Sandybridge but 8 on Haswell) so we report the missing counter without
  89     // crashing.
  90     errs() << pfm_strerror(Result) << " - cannot create event " << EventString
  91            << "\n";
  92   }
  93   if (Fstr) {
  94     FullQualifiedEventString = Fstr;
  95     free(Fstr);
  96   }
  97 #endif
  98 }
  99
 100 StringRef PerfEvent::name() const { return EventString; }
 101
 102 bool PerfEvent::valid() const { return !FullQualifiedEventString.empty(); }
 103
 104 const perf_event_attr *PerfEvent::attribute() const { return Attr; }
 105
 106 StringRef PerfEvent::getPfmEventString() const {
 107   return FullQualifiedEventString;
 108 }
 109
 110 Counter::Counter(PerfEvent &&E, pid_t ProcessID) : Event(std::move(E)) {
 111   assert(Event.valid());
 112   IsDummyEvent = Event.name() == PerfEvent::DummyEventString;
 113   if (!IsDummyEvent)
 114     initRealEvent(E, ProcessID);
 115 }
 116
 117 #ifdef HAVE_LIBPFM
 118 void Counter::initRealEvent(const PerfEvent &E, pid_t ProcessID) {
 119   const int Cpu = -1;     // measure any processor.
 120   const int GroupFd = -1; // no grouping of counters.
 121   const uint32_t Flags = 0;
 122   perf_event_attr AttrCopy = *Event.attribute();
 123   FileDescriptor = perf_event_open(&AttrCopy, ProcessID, Cpu, GroupFd, Flags);
 124   if (FileDescriptor == -1) {
 125     errs() << "Unable to open event. ERRNO: " << strerror(errno)
 126            << ". Make sure your kernel allows user "
 127               "space perf monitoring.\nYou may want to try:\n$ sudo sh "
 128               "-c 'echo -1 > /proc/sys/kernel/perf_event_paranoid'.\n"
 129            << "If you are debugging and just want to execute the snippet "
 130               "without actually reading performance counters, "
 131               "pass --use-dummy-perf-counters command line option.\n";
 132   }
 133   assert(FileDescriptor != -1 && "Unable to open event");
 134 }
 135
 136 Counter::~Counter() {
 137   if (!IsDummyEvent)
 138     close(FileDescriptor);
 139 }
 140
 141 void Counter::start() {
 142   if (!IsDummyEvent)
 143     ioctl(FileDescriptor, PERF_EVENT_IOC_RESET, 0);
 144 }
 145
 146 void Counter::stop() {
 147   if (!IsDummyEvent)
 148     ioctl(FileDescriptor, PERF_EVENT_IOC_DISABLE, 0);
 149 }
 150
 151 int64_t Counter::read() const {
 152   auto ValueOrError = readOrError();
 153   if (ValueOrError) {
 154     if (!ValueOrError.get().empty())
 155       return ValueOrError.get()[0];
 156     errs() << "Counter has no reading\n";
 157   } else
 158     errs() << ValueOrError.takeError() << "\n";
 159   return -1;
 160 }
 161
 162 llvm::Expected<llvm::SmallVector<int64_t, 4>>
 163 Counter::readOrError(StringRef /*unused*/) const {
 164   int64_t Count = 0;
 165   if (!IsDummyEvent) {
 166     ssize_t ReadSize = ::read(FileDescriptor, &Count, sizeof(Count));
 167     if (ReadSize != sizeof(Count))
 168       return llvm::make_error<llvm::StringError>("Failed to read event counter",
 169                                                  llvm::errc::io_error);
 170   } else {
 171     Count = 42;
 172   }
 173
 174   llvm::SmallVector<int64_t, 4> Result;
 175   Result.push_back(Count);
 176   return Result;
 177 }
 178
 179 int Counter::numValues() const { return 1; }
 180 #else
 181
 182 void Counter::initRealEvent(const PerfEvent &, pid_t ProcessID) {}
 183
 184 Counter::~Counter() = default;
 185
 186 void Counter::start() {}
 187
 188 void Counter::stop() {}
 189
 190 int64_t Counter::read() const { return 42; }
 191
 192 llvm::Expected<llvm::SmallVector<int64_t, 4>>
 193 Counter::readOrError(StringRef /*unused*/) const {
 194   if (IsDummyEvent) {
 195     llvm::SmallVector<int64_t, 4> Result;
 196     Result.push_back(42);
 197     return Result;
 198   }
 199   return llvm::make_error<llvm::StringError>("Not implemented",
 200                                              llvm::errc::io_error);
 201 }
 202
 203 int Counter::numValues() const { return 1; }
 204
 205 #endif
 206
 207 } // namespace pfm
 208 } // namespace exegesis
 209 } // namespace llvm