simpleperf: refactor event_type.cpp.

Currently simpleperf collects all event types at initialization,
including scanning tracefs to get tracepoint events. It takes
about 50ms and most event types are not used.

This patch refactors event_type.cpp, adding EventTypeFinder classes
for different type sources. And each finder supports two operations:
1. get all event types.
2. find an event type by name.

Then TracepointSystemFinder doesn't need to scan tracefs to find a
tracepoint event type.

Also add EventTypeManager to manage event type finders.

This reduces prepare recording time from about 68ms to 20ms on flame.

Bug: 166335356
Test: run simpleperf_unit_test.

Change-Id: I8379cb5e59ba68509de0d5116f2493eb038fea17

1 files changed, 39 insertions, 10 deletions

diff --git a/simpleperf/event_type.h b/simpleperf/event_type.h
index 71797975..cd16d45b 100644
--- a/simpleperf/event_type.h
+++ b/simpleperf/event_type.h
@@ -26,6 +26,8 @@
 
 namespace simpleperf {
 
+inline const std::string kETMEventName = "cs-etm";
+
 // EventType represents one type of event, like cpu_cycle_event, cache_misses_event.
 // The user knows one event type by its name, and the kernel knows one event type by its
 // (type, config) pair. EventType connects the two representations, and tells the user if
@@ -48,6 +50,9 @@ struct EventType {
   bool IsPmuEvent() const {
     return name.find('/') != std::string::npos;
   }
+  bool IsEtmEvent() const {
+    return name == kETMEventName;
+  }
 
   std::vector<int> GetPmuCpumask();
 
@@ -58,9 +63,6 @@ struct EventType {
   std::string limited_arch;
 };
 
-bool SetTracepointEventsFilePath(const std::string& filepath);
-std::string GetTracepointEvents();
-
 // Used to temporarily change event types returned by GetAllEventTypes().
 class ScopedEventTypes {
  public:
@@ -68,15 +70,8 @@ class ScopedEventTypes {
 
   ScopedEventTypes(const std::string& event_type_str);
   ~ScopedEventTypes();
-
- private:
-  std::set<EventType> saved_event_types_;
-  uint32_t saved_etm_event_type_;
 };
 
-const std::set<EventType>& GetAllEventTypes();
-const EventType* FindEventTypeByName(const std::string& name, bool report_error = true);
-
 struct EventTypeAndModifier {
   std::string name;
   EventType event_type;
@@ -98,6 +93,40 @@ struct EventTypeAndModifier {
   }
 };
 
+enum class EventFinderType;
+class EventTypeFinder;
+class RawTypeFinder;
+class TracepointSystemFinder;
+
+class EventTypeManager {
+ public:
+  static EventTypeManager& Instance() { return instance_; }
+  ~EventTypeManager();
+
+  bool ReadTracepointsFromFile(const std::string& filepath);
+  bool WriteTracepointsToFile(const std::string& filepath);
+
+  // Iterate through all event types, and stop when callback returns false.
+  bool ForEachType(const std::function<bool (const EventType&)>& callback);
+  const EventType* FindType(const std::string& name);
+
+  const EventType* AddRawType(const std::string& name);
+  const EventTypeFinder* GetScopedFinder() { return scoped_finder_.get(); }
+  void SetScopedFinder(std::unique_ptr<EventTypeFinder>&& finder);
+
+ private:
+  EventTypeManager();
+  std::unique_ptr<EventTypeFinder>& GetFinder(EventFinderType type);
+  RawTypeFinder& GetRawTypeFinder();
+  TracepointSystemFinder& GetTracepointSystemFinder();
+
+  static EventTypeManager instance_;
+
+  std::vector<std::unique_ptr<EventTypeFinder>> type_finders_;
+  std::unique_ptr<EventTypeFinder> scoped_finder_;
+};
+
+const EventType* FindEventTypeByName(const std::string& name, bool report_error = true);
 std::unique_ptr<EventTypeAndModifier> ParseEventType(const std::string& event_type_str);
 bool IsEtmEventType(uint32_t type);