Error handling log intermediate output delegate (#9761)

### Summary

This PR contains a fix for all `log_intermediate_output_delegate`
methods which can now propagate any error caught inside of
`log_intermediate_output_delegate_helper`. Fixes
#9549

release notes: `log_intermediate_output_delegate` no longer aborts
runtime if parameters delegate debug index or name are invalid. Instead,
an error is returned.

### Test plan

Tests for this PR can be verified by building `sdk_etdump_tests` and
using `ctest`

---------

Co-authored-by: Gasoonjia <[email protected]>

Author: dillondesilva

devtools/etdump/etdump_flatcc.cpp

@@ -36,7 +36,6 @@ using ::executorch::runtime::Tag;
 
 namespace executorch {
 namespace etdump {
-
 namespace {
 
 executorch_flatbuffer_ScalarType_enum_t get_flatbuffer_scalar_type(
@@ -311,49 +310,59 @@ Result<bool> ETDumpGen::log_intermediate_output_delegate(
     const char* name,
     DebugHandle delegate_debug_index,
     const Tensor& output) {
-  log_intermediate_output_delegate_helper(name, delegate_debug_index, output);
-  return true;
+  Result<bool> result = log_intermediate_output_delegate_helper(
+      name, delegate_debug_index, output);
+  return result;
 }
 
 Result<bool> ETDumpGen::log_intermediate_output_delegate(
     const char* name,
     DebugHandle delegate_debug_index,
     const ArrayRef<Tensor> output) {
   log_intermediate_output_delegate_helper(name, delegate_debug_index, output);
-  return true;
+  Result<bool> result = log_intermediate_output_delegate_helper(
+      name, delegate_debug_index, output);
+  return result;
 }
 
 Result<bool> ETDumpGen::log_intermediate_output_delegate(
     const char* name,
     DebugHandle delegate_debug_index,
     const int& output) {
   log_intermediate_output_delegate_helper(name, delegate_debug_index, output);
-  return true;
+  Result<bool> result = log_intermediate_output_delegate_helper(
+      name, delegate_debug_index, output);
+  return result;
 }
 
 Result<bool> ETDumpGen::log_intermediate_output_delegate(
     const char* name,
     DebugHandle delegate_debug_index,
     const bool& output) {
   log_intermediate_output_delegate_helper(name, delegate_debug_index, output);
-  return true;
+  Result<bool> result = log_intermediate_output_delegate_helper(
+      name, delegate_debug_index, output);
+  return result;
 }
 
 Result<bool> ETDumpGen::log_intermediate_output_delegate(
     const char* name,
     DebugHandle delegate_debug_index,
     const double& output) {
   log_intermediate_output_delegate_helper(name, delegate_debug_index, output);
-  return true;
+  Result<bool> result = log_intermediate_output_delegate_helper(
+      name, delegate_debug_index, output);
+  return result;
 }
 
 template <typename T>
-void ETDumpGen::log_intermediate_output_delegate_helper(
+Result<bool> ETDumpGen::log_intermediate_output_delegate_helper(
     const char* name,
     DebugHandle delegate_debug_index,
     const T& output) {
-  ET_CHECK_MSG(
+  ET_CHECK_OR_RETURN_ERROR(
       (name == nullptr) ^ (delegate_debug_index == -1),
+      InvalidArgument,
       "Only name or delegate_debug_index can be valid. Check DelegateMappingBuilder documentation for more details.");
 
   check_ready_to_add_events();
@@ -413,7 +422,10 @@ void ETDumpGen::log_intermediate_output_delegate_helper(
     etdump_Value_bool_value_add(builder_, bool_ref);
     etdump_Value_val_add(builder_, etdump_ValueType_Bool);
   } else {
-    ET_CHECK_MSG(0, "Unsupported output type for intermediate logging\n");
+    ET_CHECK_OR_RETURN_ERROR(
+        0,
+        InvalidArgument,
+        "Unsupported output type for intermediate logging\n");
   }
 
   auto value_ref = etdump_Value_end(builder_);
@@ -424,6 +436,8 @@ void ETDumpGen::log_intermediate_output_delegate_helper(
   etdump_RunData_events_push_start(builder_);
   etdump_Event_debug_event_add(builder_, debug_event);
   etdump_RunData_events_push_end(builder_);
+
+  return true;
 }
 
 void ETDumpGen::end_profiling(EventTracerEntry prof_entry) {

devtools/etdump/etdump_flatcc.h

@@ -171,7 +171,7 @@ class ETDumpGen : public ::executorch::runtime::EventTracer {
    * Supported types include tensor, tensor array, int, bool and double.
    */
   template <typename T>
-  void log_intermediate_output_delegate_helper(
+  Result<bool> log_intermediate_output_delegate_helper(
       const char* name,
       ::executorch::runtime::DebugHandle delegate_debug_index,
       const T& output);

devtools/etdump/tests/etdump_test.cpp

@@ -27,11 +27,13 @@ using ::executorch::aten::ScalarType;
 using ::executorch::aten::Tensor;
 using ::executorch::etdump::ETDumpGen;
 using ::executorch::etdump::ETDumpResult;
+using ::executorch::etdump::Result;
 using ::executorch::extension::testing::TempFile;
 using ::executorch::runtime::AllocatorID;
 using ::executorch::runtime::ArrayRef;
 using ::executorch::runtime::BoxedEvalueList;
 using ::executorch::runtime::DelegateDebugIdType;
+using ::executorch::runtime::Error;
 using ::executorch::runtime::EValue;
 using ::executorch::runtime::EventTracerEntry;
 using ::executorch::runtime::LoggedEValueType;
@@ -529,14 +531,52 @@ TEST_F(ProfilerETDumpTest, LogDelegateIntermediateOutput) {
         etdump_gen[i]->set_data_sink(&file_data_sink.get());
       }
 
+      // Only a valid name or delegate debug index should be passed in. If valid
+      // entries are passed in for both then the test should assert out.
+      Result<bool> log_tensor_result =
+          etdump_gen[i]->log_intermediate_output_delegate(
+              "test_event_tensor",
+              static_cast<torch::executor::DebugHandle>(2589),
+              tf.ones({3, 2}));
+
+      std::vector<Tensor> tensors = {tf.ones({5, 4}), tf.ones({7, 6})};
+      Result<bool> log_tensor_list_result =
+          etdump_gen[i]->log_intermediate_output_delegate(
+              nullptr,
+              static_cast<torch::executor::DebugHandle>(-1),
+              ArrayRef<Tensor>(tensors.data(), tensors.size()));
+
+      Result<bool> log_int_result =
+          etdump_gen[i]->log_intermediate_output_delegate(
+              "test_event_tensor",
+              static_cast<torch::executor::DebugHandle>(2589),
+              10);
+
+      Result<bool> log_double_result =
+          etdump_gen[i]->log_intermediate_output_delegate(
+              "test_event_tensor",
+              static_cast<torch::executor::DebugHandle>(2589),
+              29.82);
+
+      Result<bool> log_bool_result =
+          etdump_gen[i]->log_intermediate_output_delegate(
+              nullptr, static_cast<torch::executor::DebugHandle>(-1), 29.82);
+
+      ASSERT_EQ(log_tensor_result.error(), Error::InvalidArgument);
+      ASSERT_EQ(log_tensor_list_result.error(), Error::InvalidArgument);
+      ASSERT_EQ(log_int_result.error(), Error::InvalidArgument);
+      ASSERT_EQ(log_double_result.error(), Error::InvalidArgument);
+      ASSERT_EQ(log_bool_result.error(), Error::InvalidArgument);
+
+      // Now we check log intermediate output delegate with valid args
+
       // Log a tensor
       etdump_gen[i]->log_intermediate_output_delegate(
           "test_event_tensor",
           static_cast<torch::executor::DebugHandle>(-1),
           tf.ones({3, 2}));
 
       // Log a tensor list
-      std::vector<Tensor> tensors = {tf.ones({5, 4}), tf.ones({7, 6})};
       etdump_gen[i]->log_intermediate_output_delegate(
           "test_event_tensorlist",
           static_cast<torch::executor::DebugHandle>(-1),