[ET-VK] Introduce ShaderResult struct for SDK data

backends/vulkan/runtime/VulkanBackend.cpp

@@ -593,16 +593,16 @@ class VulkanBackend final : public ::executorch::runtime::BackendInterface {
 #ifdef ET_EVENT_TRACER_ENABLED
     runtime::EventTracer* event_tracer = context.event_tracer();
     compute_graph->context()->querypool().extract_results();
-    for (const auto& tup :
+    for (const auto& r :
          compute_graph->context()->querypool().get_shader_timestamp_data()) {
       std::string event_name =
-          std::get<0>(tup) + "_" + std::to_string(std::get<1>(tup));
+          r.kernel_name + "_" + std::to_string(r.dispatch_id);
       event_tracer_log_profiling_delegate(
           event_tracer,
           event_name.c_str(),
-          -1,
-          std::get<2>(tup),
-          std::get<3>(tup));
+          /* delegate_debug_id = */ -1,
+          r.start_time_ns,
+          r.end_time_ns);
     }
 #endif // ET_EVENT_TRACER_ENABLED
 

backends/vulkan/runtime/vk_api/QueryPool.cpp

@@ -176,22 +176,21 @@ std::string stringize(const VkExtent3D& extents) {
      << "}";
   return ss.str();
 }
-std::vector<std::tuple<std::string, uint32_t, uint64_t, uint64_t>>
-QueryPool::get_shader_timestamp_data() {
+std::vector<ShaderResult> QueryPool::get_shader_timestamp_data() {
   if (querypool_ == VK_NULL_HANDLE) {
     return {};
   }
   std::lock_guard<std::mutex> lock(mutex_);
-  std::vector<std::tuple<std::string, uint32_t, uint64_t, uint64_t>>
-      shader_timestamp_data;
+  std::vector<ShaderResult> shader_result;
   for (ShaderDuration& entry : shader_durations_) {
-    shader_timestamp_data.emplace_back(std::make_tuple(
-        entry.kernel_name,
-        entry.dispatch_id,
-        entry.start_time_ns,
-        entry.end_time_ns));
+    shader_result.push_back(ShaderResult{
+        .kernel_name = entry.kernel_name,
+        .dispatch_id = entry.dispatch_id,
+        .start_time_ns = entry.start_time_ns,
+        .end_time_ns = entry.end_time_ns,
+    });
   }
-  return shader_timestamp_data;
+  return shader_result;
 }
 
 std::string QueryPool::generate_string_report() {

backends/vulkan/runtime/vk_api/QueryPool.h

@@ -26,6 +26,13 @@
 namespace vkcompute {
 namespace vkapi {
 
+struct ShaderResult final {
+  const std::string kernel_name;
+  const uint32_t dispatch_id;
+  const uint64_t start_time_ns;
+  const uint64_t end_time_ns;
+};
+
 struct QueryPoolConfig final {
   uint32_t max_query_count = VULKAN_QUERY_POOL_SIZE;
   uint32_t initial_reserve_size = 256u;
@@ -97,8 +104,7 @@ class QueryPool final {
 
   void extract_results();
 
-  std::vector<std::tuple<std::string, uint32_t, uint64_t, uint64_t>>
-  get_shader_timestamp_data();
+  std::vector<ShaderResult> get_shader_timestamp_data();
   void print_results(const bool tsv_format = false);
   unsigned long get_total_shader_ns(std::string kernel_name);
   unsigned long get_mean_shader_ns(std::string kernel_name);

backends/vulkan/test/op_tests/utils/gen_benchmark_vk.py

@@ -269,22 +269,18 @@ def generate_benchmark_fixture(self) -> str:
   return at::from_blob(acc.data(), sizes, dtype).detach().clone();
 }}
 
-using ShaderEntry = std::tuple<std::string, uint32_t, uint64_t, uint64_t>;
-using QueryPoolResults = std::vector<ShaderEntry>;
+using QueryPoolResults = std::vector<vkcompute::vkapi::ShaderResult>;
 using ShaderTimes = std::unordered_map<std::string, std::vector<uint64_t>>;
 
 void process_querypool_results(
     QueryPoolResults& results,
     ShaderTimes& shader_times) {{
-  for (const ShaderEntry& entry : results) {{
-    std::string kernel_name = std::get<0>(entry);
-    std::uint64_t start_ns = std::get<2>(entry);
-    std::uint64_t end_ns = std::get<3>(entry);
-    std::uint64_t duration_ns = end_ns - start_ns;
-    if (shader_times.find(kernel_name) == shader_times.end()) {{
-      shader_times[kernel_name] = std::vector<uint64_t>();
+  for (const vkcompute::vkapi::ShaderResult& r : results) {{
+    uint64_t duration_ns = r.end_time_ns - r.start_time_ns;
+    if (shader_times.find(r.kernel_name) == shader_times.end()) {{
+      shader_times[r.kernel_name] = std::vector<uint64_t>();
     }}
-    shader_times[kernel_name].emplace_back(duration_ns);
+    shader_times[r.kernel_name].emplace_back(duration_ns);
   }}
 }}