etdumpfilter impl (#9752)

Summary:
Pull Request resolved: #9752

Introduce ETDumpFilter for filtering logged delegation intermediate data.
Details can be found in #9260

Differential Revision: D72025517

Author: Gasoonjia

Diff for: devtools/etdump/etdump_filter.cpp

@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <executorch/devtools/etdump/etdump_filter.h>
+
+#include <executorch/runtime/core/error.h>
+#include <executorch/runtime/platform/assert.h>
+
+using ::executorch::runtime::DebugHandle;
+using ::executorch::runtime::Error;
+
+namespace executorch {
+namespace etdump {
+
+ETDumpFilter::ETDumpFilter()
+    : regex_count_(0), range_start_(0), range_end_(0) {}
+
+Result<bool> ETDumpFilter::add_regex(const char* pattern) {
+  if (regex_count_ >= MAX_REGEX_PATTERNS) {
+    return Error::OutOfResources; // Error code for exceeding max patterns
+  }
+  size_t len = strlen(pattern);
+  if (len >= MAX_PATTERN_LENGTH) {
+    return Error::InvalidArgument; // Pattern too long
+  }
+  strcpy(regex_patterns_[regex_count_], pattern);
+  regex_patterns_[regex_count_][len] = '\0';
+  regex_count_++;
+  return true;
+}
+
+Result<bool> ETDumpFilter::set_debug_handle_range(size_t start, size_t end) {
+  if (start >= end) {
+    return Error::InvalidArgument; // Start is greater than end
+  }
+  if (start < 0 || end < 0) {
+    return Error::InvalidArgument; // Start or end is negative
+  }
+  range_start_ = start;
+  range_end_ = end;
+  return true;
+}
+
+Result<bool> ETDumpFilter::filter_name_(const char* name) {
+  if (name == nullptr) {
+    return Error::InvalidArgument; // Name is null
+  }
+  if (regex_count_ == 0) {
+    return true;
+  }
+  for (size_t i = 0; i < regex_count_; ++i) {
+    if (RE2::FullMatch(name, regex_patterns_[i])) {
+      return true;
+    }
+  }
+  return false;
+}
+Result<bool> ETDumpFilter::filter_delegate_debug_index_(
+    DebugHandle debug_handle) {
+  if (debug_handle == runtime::kUnsetDebugHandle) {
+    return Error::InvalidArgument; // Delegate debug index is unset
+  }
+
+  if (range_start_ == 0 && range_end_ == 0) {
+    return true;
+  }
+
+  if (debug_handle < range_start_ || debug_handle >= range_end_) {
+    return false;
+  }
+
+  return true;
+}
+
+Result<bool> ETDumpFilter::filter(
+    const char* name,
+    DebugHandle delegate_debug_index) {
+  if (name) {
+    return filter_name_(name);
+  } else {
+    return filter_delegate_debug_index_(delegate_debug_index);
+  }
+}
+
+size_t ETDumpFilter::get_n_regex() const {
+  return regex_count_;
+}
+
+} // namespace etdump
+} // namespace executorch

Diff for: devtools/etdump/etdump_filter.h

@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <re2/re2.h>
+
+#include <executorch/runtime/core/event_tracer.h>
+#include <executorch/runtime/core/result.h>
+#include <executorch/runtime/platform/platform.h>
+
+namespace executorch {
+namespace etdump {
+
+using ::executorch::runtime::Result;
+
+/**
+ * ETDumpFilter is a class that filters intermediate output based on output's
+ * name by full regex filtering, or delegate debug indices by range-based
+ * filtering.
+ *
+ * Note that this filter supports up to MAX_REGEX_PATTERNS regex patterns with a
+ * maximum length of MAX_PATTERN_LENGTH characters each.
+ */
+
+class ETDumpFilter : public ::executorch::runtime::EventTracerFilterBase {
+ public:
+  static const size_t MAX_REGEX_PATTERNS =
+      4; // Maximum number of regex patterns
+  static const size_t MAX_PATTERN_LENGTH = 32; // Maximum length of a pattern
+  ETDumpFilter();
+  ~ETDumpFilter() override = default;
+  /**
+   * Adds a regex pattern to the filter.
+   *
+   * @param[in] pattern A c string representing the regex pattern to be added.
+   *
+   * @return A Result<bool> indicating the success or failure of adding the
+   * regex pattern.
+   *         - True if the pattern is successfully added.
+   *         - False if the pattern could not be added or if the maximum number
+   * of patterns is exceeded.
+   *         - An error code if number of pattern has reached to cap, or any
+   * error occurs during regex compilation.
+   */
+  Result<bool> add_regex(const char* pattern);
+  /**
+   * Sets the range for the delegate debug index filtering as [start, end).
+   * Note that this function will flush the existing range.
+   *
+   * @param[in] start The start of the range for filtering.
+   * @param[in] end The end of the range for filtering.
+   *
+   * @return A Result<bool> indicating the success or failure of setting the
+   * range.
+   *         - True if the range is successfully set.
+   *         - False if the start is greater than the end.
+   *         - An error code if an error occurs.
+   */
+  Result<bool> set_debug_handle_range(size_t start, size_t end);
+
+  /**
+   * Filters events based on the given name or delegate debug index.
+   *
+   * Note that everytime only one of either the name or delegate_debug_index
+   * should be passed in.
+   *
+   * @param[in] name A pointer to a string representing the `name` of the
+   * event. If `delegate_debug_index` is not set to kUnsetDebugHandle, `name`
+   * should be set to nullptr.
+   *
+   * @param[in] delegate_debug_index A DebugHandle representing the debug index
+   * of the delegate. If `name` is not nullptr, this should be set to
+   * kUnsetDebugHandle.
+   *
+   * @return A Result<bool> indicating whether the event matches the filter
+   * criteria.
+   *         - True if the event matches the filter, or filter is unset.
+   *         - False if the event does not match or is unknown.
+   *         - An error code if an error occurs during filtering.
+   */
+  Result<bool> filter(
+      const char* name,
+      ::executorch::runtime::DebugHandle delegate_debug_index) override;
+
+  /**
+   * Returns the number of regex patterns in the filter.
+   */
+  size_t get_n_regex() const;
+
+ private:
+  char regex_patterns_[MAX_REGEX_PATTERNS][MAX_PATTERN_LENGTH];
+  size_t regex_count_;
+  size_t range_start_;
+  size_t range_end_;
+  Result<bool> filter_name_(const char* name);
+  Result<bool> filter_delegate_debug_index_(
+      ::executorch::runtime::DebugHandle delegate_debug_index);
+};
+
+} // namespace etdump
+} // namespace executorch

Diff for: devtools/etdump/etdump_flatcc.cpp

@@ -15,6 +15,7 @@
 #include <executorch/devtools/etdump/etdump_schema_flatcc_builder.h>
 #include <executorch/devtools/etdump/etdump_schema_flatcc_reader.h>
 #include <executorch/devtools/etdump/utils.h>
+#include <executorch/runtime/core/error.h>
 #include <executorch/runtime/core/exec_aten/exec_aten.h>
 #include <executorch/runtime/core/exec_aten/util/scalar_type_util.h>
 #include <executorch/runtime/platform/assert.h>
@@ -27,6 +28,7 @@ using ::executorch::runtime::ArrayRef;
 using ::executorch::runtime::ChainID;
 using ::executorch::runtime::DebugHandle;
 using ::executorch::runtime::DelegateDebugIdType;
+using ::executorch::runtime::Error;
 using ::executorch::runtime::EValue;
 using ::executorch::runtime::EventTracerEntry;
 using ::executorch::runtime::LoggedEValueType;

Diff for: devtools/etdump/etdump_flatcc.h

@@ -9,7 +9,6 @@
 #pragma once
 
 #include <cstdint>
-#include <memory>
 
 #include <executorch/devtools/etdump/data_sinks/buffer_data_sink.h>
 #include <executorch/devtools/etdump/data_sinks/data_sink_base.h>

Diff for: devtools/etdump/targets.bzl

@@ -101,6 +101,27 @@ def define_common_targets():
     for aten_mode in get_aten_mode_options():
         aten_suffix = "_aten" if aten_mode else ""
 
+        runtime.cxx_library(
+            name = "etdump_filter" + aten_suffix,
+            srcs = [
+                "etdump_filter.cpp",
+            ],
+            exported_headers = [
+                "etdump_filter.h",
+            ],
+            deps = [
+                "//executorch/runtime/platform:platform",
+            ],
+            exported_deps = [
+                "fbsource//third-party/re2:re2",
+                "//executorch/runtime/core:event_tracer" + aten_suffix,
+            ],
+            visibility = [
+                "//executorch/...",
+                "@EXECUTORCH_CLIENTS",
+            ],
+        )
+
         runtime.cxx_library(
             name = "etdump_flatcc" + aten_suffix,
             srcs = [

Diff for: devtools/etdump/tests/etdump_filter_test.cpp

@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <gtest/gtest.h>
+
+#include <executorch/devtools/etdump/etdump_filter.h>
+#include <executorch/runtime/platform/runtime.h>
+
+#include <cstring>
+
+using ::executorch::etdump::ETDumpFilter;
+using ::executorch::runtime::Error;
+using ::executorch::runtime::kUnsetDebugHandle;
+using ::executorch::runtime::Result;
+
+class ETDumpFilterTest : public ::testing::Test {
+ protected:
+  ETDumpFilter filter;
+
+  void SetUp() override {
+    torch::executor::runtime_init();
+  }
+
+  void TearDown() override {}
+};
+
+TEST_F(ETDumpFilterTest, AddRegexPatternSuccess) {
+  Result<bool> result = filter.add_regex("test.*");
+  EXPECT_TRUE(result.ok());
+  EXPECT_TRUE(result.get());
+}
+
+TEST_F(ETDumpFilterTest, AddRegexPatternFailure) {
+  // Add maximum number of patterns
+  for (size_t i = 0; i < ETDumpFilter::MAX_REGEX_PATTERNS; ++i) {
+    Result<bool> result = filter.add_regex("pattern");
+    EXPECT_TRUE(result.ok());
+    EXPECT_TRUE(result.get());
+  }
+  // Attempt to add one more pattern
+  Result<bool> result = filter.add_regex("extra_pattern");
+  EXPECT_FALSE(result.ok());
+}
+
+TEST_F(ETDumpFilterTest, SetDebugHandleRangeSuccess) {
+  Result<bool> result = filter.set_debug_handle_range(10, 20);
+  EXPECT_TRUE(result.ok());
+  EXPECT_TRUE(result.get());
+}
+
+TEST_F(ETDumpFilterTest, SetDebugHandleRangeFailure) {
+  Result<bool> result = filter.set_debug_handle_range(20, 10);
+  EXPECT_EQ(result.error(), Error::InvalidArgument);
+}
+
+TEST_F(ETDumpFilterTest, FilterByNameSuccess) {
+  filter.add_regex("event.*");
+  Result<bool> result = filter.filter("event_name", kUnsetDebugHandle);
+  EXPECT_TRUE(result.ok());
+  EXPECT_TRUE(result.get());
+}
+
+TEST_F(ETDumpFilterTest, PartialMatchingFailed) {
+  filter.add_regex("event.*");
+  Result<bool> result = filter.filter("non_matching_event", kUnsetDebugHandle);
+  EXPECT_TRUE(result.ok());
+  EXPECT_FALSE(result.get());
+}
+
+TEST_F(ETDumpFilterTest, FilterByDelegateDebugIndexSuccess) {
+  filter.set_debug_handle_range(10, 20);
+  Result<bool> result = filter.filter(nullptr, 15);
+  EXPECT_TRUE(result.ok());
+  EXPECT_TRUE(result.get());
+}
+
+TEST_F(ETDumpFilterTest, FilterByDelegateDebugIndexFailure) {
+  filter.set_debug_handle_range(10, 20);
+  Result<bool> result = filter.filter(nullptr, 25);
+  EXPECT_TRUE(result.ok());
+  EXPECT_FALSE(result.get());
+}
+
+TEST_F(ETDumpFilterTest, NaiveFilterNameInputCanSucceed) {
+  Result<bool> result = filter.filter("any_input", kUnsetDebugHandle);
+  EXPECT_TRUE(result.ok());
+  EXPECT_TRUE(result.get());
+}
+
+TEST_F(ETDumpFilterTest, NaiveFilterDebugHandleInputCanSucceed) {
+  Result<bool> result = filter.filter(nullptr, 12345);
+  EXPECT_TRUE(result.ok());
+  EXPECT_TRUE(result.get());
+}
+
+TEST_F(ETDumpFilterTest, NoMatchFirstThenMatch) {
+  filter.add_regex("non_matching_pattern");
+  Result<bool> result_1 = filter.filter("matching_event", kUnsetDebugHandle);
+  EXPECT_TRUE(result_1.ok());
+  EXPECT_FALSE(result_1.get());
+  filter.add_regex("matching_.*");
+  Result<bool> result_2 = filter.filter("matching_event", kUnsetDebugHandle);
+  EXPECT_TRUE(result_2.ok());
+  EXPECT_TRUE(result_2.get());
+}
+
+TEST_F(ETDumpFilterTest, MatchRegexFirstThen) {
+  filter.add_regex("matching.*");
+  Result<bool> result_1 = filter.filter("matching_event", kUnsetDebugHandle);
+  EXPECT_TRUE(result_1.ok());
+  EXPECT_TRUE(result_1.get());
+  filter.add_regex("non_matching_pattern");
+  Result<bool> result_2 = filter.filter("matching_event", kUnsetDebugHandle);
+  EXPECT_TRUE(result_2.ok());
+  EXPECT_TRUE(result_2.get());
+}

Diff for: devtools/etdump/tests/targets.bzl

@@ -21,3 +21,14 @@ def define_common_targets():
             "//executorch/runtime/core/exec_aten/testing_util:tensor_util",
         ],
     )
+
+    runtime.cxx_test(
+        name = "etdump_filter_test",
+        srcs = [
+            "etdump_filter_test.cpp",
+        ],
+        deps = [
+            "//executorch/devtools/etdump:etdump_filter",
+            "//executorch/runtime/platform:platform",
+        ],
+    )