Turn EventDescription into class

CMakeLists.txt

@@ -185,6 +185,7 @@ set(SOURCE_FILES
     src/process_controller.cpp
 
     src/perf/event_provider.cpp
+    src/perf/event.cpp
 
     src/perf/bio/block_device.cpp
     src/perf/counter/counter_provider.cpp
@@ -196,8 +197,8 @@ set(SOURCE_FILES
 
     src/perf/sample/writer.cpp
     src/perf/time/converter.cpp src/perf/time/reader.cpp
-    src/perf/tracepoint/format.cpp
     src/perf/tracepoint/writer.cpp
+    src/perf/tracepoint/event.cpp
     src/perf/syscall/writer.cpp
 
     src/time/time.cpp

include/lo2s/measurement_scope.hpp

@@ -34,6 +34,7 @@ enum class MeasurementScopeType
     BIO,
     SYSCALL,
     CUDA,
+    TRACEPOINT,
     UNKNOWN
 };
 
@@ -85,6 +86,11 @@ struct MeasurementScope
         return { MeasurementScopeType::CUDA, s };
     }
 
+    static MeasurementScope tracepoint(ExecutionScope s)
+    {
+        return { MeasurementScopeType::TRACEPOINT, s };
+    }
+
     friend bool operator==(const MeasurementScope& lhs, const MeasurementScope& rhs)
     {
         return (lhs.scope == rhs.scope) && lhs.type == rhs.type;
@@ -119,6 +125,8 @@ struct MeasurementScope
             return fmt::format("syscall events for {}", scope.name());
         case lo2s::MeasurementScopeType::CUDA:
             return fmt::format("cuda kernel events for {}", scope.name());
+        case MeasurementScopeType::TRACEPOINT:
+            return fmt::format("tracepoint events for {}", scope.name());
         default:
             throw new std::runtime_error("Unknown ExecutionScopeType!");
         }

include/lo2s/perf/bio/writer.hpp

@@ -82,7 +82,7 @@ class Writer
 
     void write(IoReaderIdentity& identity, TracepointSampleType* header)
     {
-        if (identity.tracepoint == bio_queue_)
+        if (identity.tracepoint() == bio_queue_)
         {
             struct RecordBioQueue* event = (RecordBioQueue*)header;
 
@@ -112,7 +112,7 @@ class Writer
                 time_converter_(event->header.time), handle, mode,
                 otf2::common::io_operation_flag_type::non_blocking, size, event->sector);
         }
-        else if (identity.tracepoint == bio_issue_)
+        else if (identity.tracepoint() == bio_issue_)
         {
             struct RecordBlock* event = (RecordBlock*)header;
 
@@ -129,7 +129,7 @@ class Writer
             writer << otf2::event::io_operation_issued(time_converter_(event->header.time), handle,
                                                        event->sector);
         }
-        else if (identity.tracepoint == bio_complete_)
+        else if (identity.tracepoint() == bio_complete_)
         {
             struct RecordBlock* event = (RecordBlock*)header;
 
@@ -150,19 +150,21 @@ class Writer
         }
         else
         {
-            throw std::runtime_error("tracepoint " + identity.tracepoint.name() +
+            throw std::runtime_error("tracepoint " + identity.tracepoint().name() +
                                      " not valid for block I/O");
         }
     }
 
-    std::vector<tracepoint::EventFormat> get_tracepoints()
+    std::vector<perf::tracepoint::TracepointEvent> get_tracepoints()
     {
-
-        bio_queue_ = tracepoint::EventFormat("block:block_bio_queue");
-        bio_issue_ = tracepoint::EventFormat("block:block_rq_issue");
-        bio_complete_ = tracepoint::EventFormat("block:block_rq_complete");
-
-        return { bio_queue_, bio_issue_, bio_complete_ };
+        bio_queue_ =
+            perf::EventProvider::instance().create_tracepoint_event("block:block_bio_queue");
+        bio_issue_ =
+            perf::EventProvider::instance().create_tracepoint_event("block:block_rq_issue");
+        bio_complete_ =
+            perf::EventProvider::instance().create_tracepoint_event("block:block_rq_complete");
+
+        return { bio_queue_.value(), bio_issue_.value(), bio_complete_.value() };
     }
 
 private:
@@ -182,9 +184,11 @@ class Writer
     trace::Trace& trace_;
     time::Converter& time_converter_;
 
-    tracepoint::EventFormat bio_queue_;
-    tracepoint::EventFormat bio_issue_;
-    tracepoint::EventFormat bio_complete_;
+    // Unavailable until get_tracepoints() is called
+    std::optional<perf::tracepoint::TracepointEvent> bio_queue_;
+    std::optional<perf::tracepoint::TracepointEvent> bio_issue_;
+    std::optional<perf::tracepoint::TracepointEvent> bio_complete_;
+
     // The unit "sector" is always 512 bit large, regardless of the actual sector size of the device
     static constexpr int SECTOR_SIZE = 512;
 };

include/lo2s/perf/counter/counter_collection.hpp

@@ -21,8 +21,9 @@
 
 #pragma once
 
-#include <lo2s/perf/event_description.hpp>
+#include <lo2s/perf/event.hpp>
 
+#include <optional>
 #include <vector>
 
 namespace lo2s
@@ -33,24 +34,29 @@ namespace counter
 {
 struct CounterCollection
 {
-    EventDescription leader;
-    std::vector<EventDescription> counters;
+    std::optional<Event> leader_;
+    std::vector<Event> counters;
 
     double get_scale(int index) const
     {
         if (index == 0)
         {
-            return leader.scale;
+            return leader_.value().scale();
         }
         else
         {
-            return counters[index - 1].scale;
+            return counters[index - 1].scale();
         }
     }
 
+    Event& leader() const
+    {
+        return const_cast<Event&>(leader_.value());
+    }
+
     friend bool operator==(const CounterCollection& lhs, const CounterCollection& rhs)
     {
-        if (lhs.leader == rhs.leader)
+        if (lhs.leader_.value() == rhs.leader_.value())
         {
             return lhs.counters == rhs.counters;
         }
@@ -59,11 +65,11 @@ struct CounterCollection
 
     friend bool operator<(const CounterCollection& lhs, const CounterCollection& rhs)
     {
-        if (lhs.leader == rhs.leader)
+        if (lhs.leader_.value() == rhs.leader_.value())
         {
             return lhs.counters < rhs.counters;
         }
-        return lhs.leader < rhs.leader;
+        return lhs.leader_.value() < rhs.leader_.value();
     }
 };
 

include/lo2s/perf/counter/counter_provider.hpp

@@ -23,8 +23,9 @@
 
 #include <lo2s/measurement_scope.hpp>
 #include <lo2s/perf/counter/counter_collection.hpp>
-#include <lo2s/perf/event_description.hpp>
+#include <lo2s/perf/tracepoint/event.hpp>
 
+#include <optional>
 #include <vector>
 
 namespace lo2s
@@ -49,16 +50,19 @@ class CounterProvider
     void initialize_group_counters(const std::string& leader,
                                    const std::vector<std::string>& counters);
     void initialize_userspace_counters(const std::vector<std::string>& counters);
+    void initialize_tracepoints(const std::vector<std::string>& tracepoints);
 
     bool has_group_counters(ExecutionScope scope);
     bool has_userspace_counters(ExecutionScope scope);
 
     CounterCollection collection_for(MeasurementScope scope);
+    std::vector<std::string> get_tracepoint_event_names();
 
 private:
-    EventDescription group_leader_;
-    std::vector<EventDescription> group_events_;
-    std::vector<EventDescription> userspace_events_;
+    std::optional<Event> group_leader_;
+    std::vector<Event> group_events_;
+    std::vector<Event> userspace_events_;
+    std::vector<tracepoint::TracepointEvent> tracepoint_events_;
 };
 } // namespace counter
 } // namespace perf

include/lo2s/perf/counter/group/reader.hpp

@@ -23,8 +23,10 @@
 
 #include <lo2s/perf/counter/counter_collection.hpp>
 #include <lo2s/perf/counter/group/group_counter_buffer.hpp>
+#include <lo2s/perf/event.hpp>
 #include <lo2s/perf/event_reader.hpp>
 
+#include <optional>
 #include <vector>
 
 extern "C"
@@ -58,21 +60,9 @@ class Reader : public EventReader<T>
         struct GroupReadFormat v;
     };
 
-    ~Reader()
-    {
-        for (int fd : counter_fds_)
-        {
-            if (fd != -1)
-            {
-                ::close(fd);
-            }
-        }
-        ::close(group_leader_fd_);
-    }
-
 protected:
-    int group_leader_fd_;
-    std::vector<int> counter_fds_;
+    std::optional<EventGuard> counter_leader_;
+    std::vector<EventGuard> counters_;
     CounterCollection counter_collection_;
     GroupCounterBuffer counter_buffer_;
 };

include/lo2s/perf/counter/userspace/reader.hpp

@@ -24,6 +24,7 @@
 #include <lo2s/execution_scope.hpp>
 #include <lo2s/perf/counter/counter_collection.hpp>
 #include <lo2s/perf/counter/userspace/userspace_counter_buffer.hpp>
+#include <lo2s/perf/event_provider.hpp>
 #include <lo2s/trace/trace.hpp>
 
 #include <cstdint>
@@ -55,11 +56,11 @@ class Reader
     }
 
 protected:
-    std::vector<int> counter_fds_;
     CounterCollection counter_collection_;
     UserspaceCounterBuffer counter_buffer_;
     int timer_fd_;
 
+    std::vector<EventGuard> counters_;
     std::vector<UserspaceReadFormat> data_;
 };
 } // namespace userspace

include/lo2s/perf/counter/userspace/userspace_counter_buffer.hpp

@@ -35,10 +35,6 @@ namespace userspace
 {
 struct UserspaceReadFormat
 {
-    UserspaceReadFormat() : value(0), time_enabled(0), time_running(0)
-    {
-    }
-
     uint64_t value;
     uint64_t time_enabled;
     uint64_t time_running;