wrap the perfevent library by Viktor Leis and improve the interface for counter definition

Author: toschmidt

src/cpp-utility/perf/Counter.hpp

@@ -0,0 +1,63 @@
+#pragma once
+
+#include "PerfEvent.hpp"
+#include <cpp-utility/perf/definition/DurationCounterDefinition.hpp>
+#include <cpp-utility/perf/definition/ExtendedCounterDefinition.hpp>
+#include <cpp-utility/perf/definition/PerfCounterDefinition.hpp>
+#include <cpp-utility/std/New.hpp>
+
+namespace utility::perf {
+
+   // Duration Counters
+   static const Counter DURATION = std::new_nothrow<definition::DurationCounterDefinition<std::nano>>("duration_ms");
+   static const Counter DURATION_NS = std::new_nothrow<definition::DurationCounterDefinition<std::nano>>("duration_ns");
+   static const Counter DURATION_MS =
+      std::new_nothrow<definition::DurationCounterDefinition<std::milli>>("duration_ms");
+   static const Counter DURATION_S =
+      std::new_nothrow<definition::DurationCounterDefinition<std::ratio<1, 1>>>("duration_s");
+
+   // Perf Counters
+   static const Counter CYCLES =
+      std::new_nothrow<definition::PerfCounterDefinition>("cycles", PERF_TYPE_HARDWARE, PERF_COUNT_HW_CPU_CYCLES);
+
+   static const Counter INSTRUCTIONS =
+      std::new_nothrow<definition::PerfCounterDefinition>("instructions", PERF_TYPE_HARDWARE,
+                                                          PERF_COUNT_HW_INSTRUCTIONS);
+
+   static const Counter L1D_MISSES =
+      std::new_nothrow<definition::PerfCounterDefinition>("l1d-misses", PERF_TYPE_HW_CACHE,
+                                                          PERF_COUNT_HW_CACHE_L1D | (PERF_COUNT_HW_CACHE_OP_READ << 8) |
+                                                             (PERF_COUNT_HW_CACHE_RESULT_MISS << 16));
+
+   static const Counter L1I_MISSES =
+      std::new_nothrow<definition::PerfCounterDefinition>("l1i-misses", PERF_TYPE_HW_CACHE,
+                                                          PERF_COUNT_HW_CACHE_L1I | (PERF_COUNT_HW_CACHE_OP_READ << 8) |
+                                                             (PERF_COUNT_HW_CACHE_RESULT_MISS << 16));
+
+   static const Counter DTLB_MISSES = std::new_nothrow<definition::PerfCounterDefinition>(
+      "dtlb-misses", PERF_TYPE_HW_CACHE,
+      PERF_COUNT_HW_CACHE_DTLB | (PERF_COUNT_HW_CACHE_OP_READ << 8) | (PERF_COUNT_HW_CACHE_RESULT_MISS << 16));
+
+   static const Counter ITLB_MISSES = std::new_nothrow<definition::PerfCounterDefinition>(
+      "itlb-misses", PERF_TYPE_HW_CACHE,
+      PERF_COUNT_HW_CACHE_ITLB | (PERF_COUNT_HW_CACHE_OP_READ << 8) | (PERF_COUNT_HW_CACHE_RESULT_MISS << 16));
+
+   static const Counter LLC_MISSES =
+      std::new_nothrow<definition::PerfCounterDefinition>("llc-misses", PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_MISSES);
+
+   static const Counter BRANCH_MISSES =
+      std::new_nothrow<definition::PerfCounterDefinition>("branch-misses", PERF_TYPE_HARDWARE,
+                                                          PERF_COUNT_HW_BRANCH_MISSES);
+
+   static const Counter TASK_CLOCK =
+      std::new_nothrow<definition::PerfCounterDefinition>("task-clock", PERF_TYPE_SOFTWARE, PERF_COUNT_SW_TASK_CLOCK);
+
+   // Extended Counters, dividing two existing counters;
+   static const Counter IPC =
+      std::new_nothrow<definition::DivCounterDefinition>("ipc", std::array<Counter, 2>{INSTRUCTIONS, CYCLES});
+   static const Counter CPUS =
+      std::new_nothrow<definition::DivCounterDefinition>("cpus", std::array<Counter, 2>{TASK_CLOCK, DURATION});
+   static const Counter GHZ =
+      std::new_nothrow<definition::DivCounterDefinition>("ghz", std::array<Counter, 2>{CYCLES, TASK_CLOCK});
+
+} // namespace utility::perf

src/cpp-utility/perf/PerfCounter.hpp

@@ -0,0 +1,61 @@
+#pragma once
+
+#include <cpp-utility/compiler/CompilerHints.hpp>
+#include <cstring>
+#include <linux/perf_event.h>
+#include <sys/ioctl.h>
+#include <syscall.h>
+#include <unistd.h>
+
+namespace utility::perf {
+
+   using PerfConfig = std::pair<uint64_t, uint64_t>;
+
+   class PerfCounter {
+     private:
+      struct alignas(32) read_format {
+         uint64_t value{};
+         uint64_t time_enabled{};
+         uint64_t time_running{};
+      };
+
+      perf_event_attr pe{};
+      int fd;
+      read_format prev;
+      read_format data;
+
+     public:
+      explicit PerfCounter(PerfConfig config) : fd(0) {
+         memset(&pe, 0, sizeof(perf_event_attr));
+         pe.type = config.first;
+         pe.size = sizeof(perf_event_attr);
+         pe.config = config.second;
+         pe.disabled = true;
+         pe.inherit = 1;
+         pe.inherit_stat = 0;
+         pe.exclude_kernel = false;
+         pe.exclude_hv = false;
+         pe.read_format = PERF_FORMAT_TOTAL_TIME_ENABLED | PERF_FORMAT_TOTAL_TIME_RUNNING;
+
+         fd = syscall(__NR_perf_event_open, &pe, 0, -1, -1, 0); // NOLINT
+      }
+
+      forceinline void start() {
+         ioctl(fd, PERF_EVENT_IOC_RESET, 0);
+         ioctl(fd, PERF_EVENT_IOC_ENABLE, 0);
+         read(fd, &prev, sizeof(uint64_t) * 3);
+      }
+
+      forceinline void stop() {
+         read(fd, &data, sizeof(uint64_t) * 3);
+         ioctl(fd, PERF_EVENT_IOC_DISABLE, 0);
+      }
+
+      forceinline double get() const {
+         return static_cast<double>(data.value - prev.value) *
+            (static_cast<double>(data.time_enabled - prev.time_enabled) /
+             static_cast<double>(data.time_running - prev.time_running));
+      }
+   };
+
+} // namespace utility::perf

src/cpp-utility/perf/PerfEvent.hpp

@@ -0,0 +1,80 @@
+#pragma once
+
+#include "PerfCounter.hpp"
+#include <cpp-utility/perf/definition/CounterDefinition.hpp>
+#include <cpp-utility/std/Hash.hpp>
+
+namespace utility::perf {
+
+   using Counter = definition::Counter;
+
+   namespace definition {
+      class PerfCounterDefinition;
+      template<typename>
+      class DurationCounterDefinition;
+   } // namespace definition
+
+   class PerfEvent {
+      friend class definition::PerfCounterDefinition;
+      template<typename>
+      friend class definition::DurationCounterDefinition;
+
+     private:
+      std::vector<PerfCounter> perfCounters;
+      std::chrono::time_point<std::chrono::steady_clock> startTime;
+      std::chrono::time_point<std::chrono::steady_clock> stopTime;
+      std::unordered_map<PerfConfig, size_t> perfCounterMap;
+
+      double readPerfCounter(PerfConfig perfConfig) {
+         if (perfCounterMap.contains(perfConfig)) {
+            return perfCounters[perfCounterMap[perfConfig]].get();
+         } else {
+            return NAN;
+         };
+      }
+
+      void addCounter(Counter counter) {
+         // if creating the counter definition failed, the pointer will be null
+         if (not counter) {
+            throw std::runtime_error{"cannot add an invalid counter!"};
+         }
+
+         // we only have to take of perf counters, duration is always measured
+         if (counter->isPerfCounter() and not perfCounterMap.contains(counter->getPerfConfig())) {
+            perfCounterMap[counter->getPerfConfig()] = perfCounters.size();
+            perfCounters.emplace_back(counter->getPerfConfig());
+         }
+
+         // add additional counters needed to compute extended counters
+         for (auto* dependency : counter->dependsOn()) {
+            addCounter(dependency);
+         }
+      }
+
+     public:
+      explicit PerfEvent(const std::vector<Counter>& counters) {
+         for (auto* counter : counters) {
+            addCounter(counter);
+         }
+      }
+
+      forceinline void start() {
+         for (auto& counters : perfCounters) {
+            counters.start();
+         }
+         startTime = std::chrono::steady_clock::now();
+      }
+
+      forceinline void stop() {
+         stopTime = std::chrono::steady_clock::now();
+         for (auto& counters : perfCounters) {
+            counters.stop();
+         }
+      }
+
+      double get(Counter counter) {
+         return counter->compute(*this);
+      }
+   };
+
+} // namespace utility::perf

src/cpp-utility/perf/definition/CounterDefinition.hpp

@@ -0,0 +1,37 @@
+#include <utility>
+
+#pragma once
+
+namespace utility::perf {
+
+   class PerfEvent;
+
+   namespace definition {
+
+      class CounterDefinition {
+         friend PerfEvent;
+
+        private:
+         const std::string_view name;
+
+         virtual bool isPerfCounter() const = 0;
+
+         virtual PerfConfig getPerfConfig() const = 0;
+
+         virtual std::vector<CounterDefinition*> dependsOn() const = 0;
+
+         virtual double compute(PerfEvent&) const = 0;
+
+        protected:
+         explicit CounterDefinition(const std::string_view& name) noexcept : name(name) {}
+
+        public:
+         std::string getName() const {
+            return std::string(name);
+         }
+      };
+
+      using Counter = CounterDefinition*;
+
+   } // namespace definition
+} // namespace utility::perf

src/cpp-utility/perf/definition/DurationCounterDefinition.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+namespace utility::perf::definition {
+
+   template<typename Ratio = std::nano>
+   class DurationCounterDefinition : public CounterDefinition {
+     public:
+      explicit DurationCounterDefinition(const std::string_view& name) noexcept : CounterDefinition(name){};
+
+      bool isPerfCounter() const override {
+         return false;
+      }
+
+      PerfConfig getPerfConfig() const override {
+         throw std::runtime_error{"no perf config available!"};
+      }
+
+      std::vector<Counter> dependsOn() const override {
+         return {};
+      }
+
+      double compute(PerfEvent& event) const override {
+         return std::chrono::duration<double, Ratio>(event.stopTime - event.startTime).count();
+      }
+   };
+
+} // namespace utility::perf::definition

src/cpp-utility/perf/definition/ExtendedCounterDefinition.hpp

@@ -0,0 +1,38 @@
+#pragma once
+
+namespace utility::perf::definition {
+
+   template<size_t n_dependencies>
+   class ExtendedCounterDefinition : public CounterDefinition {
+     protected:
+      const std::array<Counter, n_dependencies> dependencies;
+
+     public:
+      ExtendedCounterDefinition(const std::string_view& name,
+                                const std::array<Counter, n_dependencies>& dependencies) noexcept
+         : CounterDefinition(name), dependencies(std::move(dependencies)) {}
+
+      bool isPerfCounter() const override {
+         return false;
+      }
+
+      PerfConfig getPerfConfig() const override {
+         throw std::runtime_error{"no perf config available!"};
+      }
+
+      std::vector<Counter> dependsOn() const override {
+         return std::vector(std::begin(dependencies), std::end(dependencies));
+      }
+   };
+
+   class DivCounterDefinition : public ExtendedCounterDefinition<2> {
+     public:
+      DivCounterDefinition(const std::string_view& name, const std::array<Counter, 2>& dependencies) noexcept
+         : ExtendedCounterDefinition(name, dependencies) {}
+
+      double compute(PerfEvent& event) const override {
+         return event.get(dependencies[0]) / event.get(dependencies[1]);
+      }
+   };
+
+} // namespace utility::perf::definition

src/cpp-utility/perf/definition/PerfCounterDefinition.hpp

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <utility>
+
+namespace utility::perf::definition {
+
+   class PerfCounterDefinition : public CounterDefinition {
+     private:
+      PerfConfig perfConfig;
+
+     public:
+      PerfCounterDefinition(const std::string_view& name, uint64_t perfTypeId, uint64_t perfEventId) noexcept
+         : CounterDefinition(name), perfConfig(std::make_pair(perfTypeId, perfEventId)) {}
+
+      bool isPerfCounter() const override {
+         return true;
+      }
+
+      PerfConfig getPerfConfig() const override {
+         return perfConfig;
+      }
+
+      std::vector<Counter> dependsOn() const override {
+         return {};
+      }
+
+      double compute(PerfEvent& event) const override {
+         return event.readPerfCounter(perfConfig);
+      }
+   };
+
+} // namespace utility::perf::definition