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 PerfEvent::~PerfEvent() {
  48 #ifdef HAVE_LIBPFM
  49   delete Attr;
  50   ;
  51 #endif
  52 }
  53
  54 PerfEvent::PerfEvent(PerfEvent &&Other)
  55     : EventString(std::move(Other.EventString)),
  56       FullQualifiedEventString(std::move(Other.FullQualifiedEventString)),
  57       Attr(Other.Attr) {
  58   Other.Attr = nullptr;
  59 }
  60
  61 PerfEvent::PerfEvent(StringRef PfmEventString)
  62     : EventString(PfmEventString.str()), Attr(nullptr) {
  63 #ifdef HAVE_LIBPFM
  64   char *Fstr = nullptr;
  65   pfm_perf_encode_arg_t Arg = {};
  66   Attr = new perf_event_attr();
  67   Arg.attr = Attr;
  68   Arg.fstr = &Fstr;
  69   Arg.size = sizeof(pfm_perf_encode_arg_t);
  70   const int Result = pfm_get_os_event_encoding(EventString.c_str(), PFM_PLM3,
  71                                                PFM_OS_PERF_EVENT, &Arg);
  72   if (isPfmError(Result)) {
  73     // We don't know beforehand which counters are available (e.g. 6 uops ports
  74     // on Sandybridge but 8 on Haswell) so we report the missing counter without
  75     // crashing.
  76     errs() << pfm_strerror(Result) << " - cannot create event " << EventString
  77            << "\n";
  78   }
  79   if (Fstr) {
  80     FullQualifiedEventString = Fstr;
  81     free(Fstr);
  82   }
  83 #endif
  84 }
  85
  86 StringRef PerfEvent::name() const { return EventString; }
  87
  88 bool PerfEvent::valid() const { return !FullQualifiedEventString.empty(); }
  89
  90 const perf_event_attr *PerfEvent::attribute() const { return Attr; }
  91
  92 StringRef PerfEvent::getPfmEventString() const {
  93   return FullQualifiedEventString;
  94 }
  95
  96 #ifdef HAVE_LIBPFM
  97 Counter::Counter(PerfEvent &&E) : Event(std::move(E)){
  98   assert(Event.valid());
  99   const pid_t Pid = 0;    // measure current process/thread.
 100   const int Cpu = -1;     // measure any processor.
 101   const int GroupFd = -1; // no grouping of counters.
 102   const uint32_t Flags = 0;
 103   perf_event_attr AttrCopy = *Event.attribute();
 104   FileDescriptor = perf_event_open(&AttrCopy, Pid, Cpu, GroupFd, Flags);
 105   if (FileDescriptor == -1) {
 106     errs() << "Unable to open event. ERRNO: " << strerror(errno)
 107            << ". Make sure your kernel allows user "
 108               "space perf monitoring.\nYou may want to try:\n$ sudo sh "
 109               "-c 'echo -1 > /proc/sys/kernel/perf_event_paranoid'\n";
 110   }
 111   assert(FileDescriptor != -1 && "Unable to open event");
 112 }
 113
 114 Counter::~Counter() { close(FileDescriptor); }
 115
 116 void Counter::start() { ioctl(FileDescriptor, PERF_EVENT_IOC_RESET, 0); }
 117
 118 void Counter::stop() { ioctl(FileDescriptor, PERF_EVENT_IOC_DISABLE, 0); }
 119
 120 int64_t Counter::read() const {
 121   auto ValueOrError = readOrError();
 122   if (ValueOrError) {
 123     if (!ValueOrError.get().empty())
 124       return ValueOrError.get()[0];
 125     errs() << "Counter has no reading\n";
 126   } else
 127     errs() << ValueOrError.takeError() << "\n";
 128   return -1;
 129 }
 130
 131 llvm::Expected<llvm::SmallVector<int64_t, 4>>
 132 Counter::readOrError(StringRef /*unused*/) const {
 133   int64_t Count = 0;
 134   ssize_t ReadSize = ::read(FileDescriptor, &Count, sizeof(Count));
 135   if (ReadSize != sizeof(Count))
 136     return llvm::make_error<llvm::StringError>("Failed to read event counter",
 137                                                llvm::errc::io_error);
 138   llvm::SmallVector<int64_t, 4> Result;
 139   Result.push_back(Count);
 140   return Result;
 141 }
 142
 143 int Counter::numValues() const { return 1; }
 144 #else
 145
 146 Counter::Counter(PerfEvent &&Event) : Event(std::move(Event)) {}
 147
 148 Counter::~Counter() = default;
 149
 150 void Counter::start() {}
 151
 152 void Counter::stop() {}
 153
 154 int64_t Counter::read() const { return 42; }
 155
 156 llvm::Expected<llvm::SmallVector<int64_t, 4>>
 157 Counter::readOrError(StringRef /*unused*/) const {
 158   return llvm::make_error<llvm::StringError>("Not implemented",
 159                                              llvm::errc::io_error);
 160 }
 161
 162 int Counter::numValues() const { return 1; }
 163
 164 #endif
 165
 166 } // namespace pfm
 167 } // namespace exegesis
 168 } // namespace llvm