Adding additional info in the UI for GFXR draw calls (#622)

angela28chen · web-flow · commit ff26a7a36558 · 2025-12-03T15:51:05.000-05:00
Highlight some important parameters of the Vulkan vkCmdDraw* commands by
adding them to the node description, namely the vertex count, index
count, and instance count.

Minor changes:
- Remove unused `current_path` parameter from
`GfxrVulkanCommandHierarchyCreator::GetArgs()`
- Remove unused `m_node_root_node_indices` member from
`GfxrVulkanCommandHierarchyCreator`
diff --git a/dive_core/CMakeLists.txt b/dive_core/CMakeLists.txt
@@ -172,7 +172,7 @@ add_dependencies(${PROJECT_NAME} adreno_header)
 add_dependencies(${PROJECT_NAME} a6xx_py)
 add_dependencies(${PROJECT_NAME} freedreno_devices_header)
 
-target_link_libraries(${PROJECT_NAME} PUBLIC absl::no_destructor)
+target_link_libraries(${PROJECT_NAME} PUBLIC absl::no_destructor absl::strings)
 
 make_directory("${FREEDRENO_ISA_DIRECTORY}")
 
diff --git a/dive_core/command_hierarchy.cpp b/dive_core/command_hierarchy.cpp
@@ -240,6 +240,14 @@ const char *CommandHierarchy::GetNodeDesc(uint64_t node_index) const
     return m_nodes.m_description[node_index].c_str();
 }
 
+//--------------------------------------------------------------------------------------------------
+void CommandHierarchy::SetNodeDesc(uint64_t node_index, const std::string &desc)
+{
+    DIVE_ASSERT(node_index < m_nodes.m_description.size());
+    m_nodes.m_description[node_index] = desc;
+    return;
+}
+
 //--------------------------------------------------------------------------------------------------
 Dive::EngineType CommandHierarchy::GetSubmitNodeEngineType(uint64_t node_index) const
 {
diff --git a/dive_core/command_hierarchy.h b/dive_core/command_hierarchy.h
@@ -218,6 +218,7 @@ class CommandHierarchy
 
     NodeType    GetNodeType(uint64_t node_index) const;
     const char *GetNodeDesc(uint64_t node_index) const;
+    void        SetNodeDesc(uint64_t node_index, const std::string &desc);
 
     Dive::EngineType GetSubmitNodeEngineType(uint64_t node_index) const;
     uint32_t         GetSubmitNodeIndex(uint64_t node_index) const;
diff --git a/dive_core/gfxr_vulkan_command_hierarchy.cpp b/dive_core/gfxr_vulkan_command_hierarchy.cpp
@@ -11,8 +11,12 @@
  limitations under the License.
 */
 
-#include "gfxr_vulkan_command_hierarchy.h"
-#include "dive_strings.h"
+#include "dive_core/gfxr_vulkan_command_hierarchy.h"
+
+#include <iostream>
+
+#include "absl/strings/numbers.h"
+#include "dive_core/dive_strings.h"
 
 namespace Dive
 {
@@ -49,6 +53,33 @@ void GfxrVulkanCommandHierarchyCreator::ConditionallyAddChild(uint64_t node_inde
     }
 }
 
+//--------------------------------------------------------------------------------------------------
+std::string GfxrVulkanCommandHierarchyCreator::GetCurrDrawCallString()
+{
+    // Early return for zero instance count
+    if (m_cur_draw_call_info.instance_count == 0)
+    {
+        return "";
+    }
+
+    std::ostringstream s;
+
+    s << "(";
+
+    if (m_cur_draw_call_info.index_count > 0)
+    {
+        s << "indexCount:" << m_cur_draw_call_info.index_count << ",";
+    }
+    else if (m_cur_draw_call_info.vertex_count > 0)
+    {
+        s << "vertexCount:" << m_cur_draw_call_info.vertex_count << ",";
+    }
+
+    s << "instanceCount:" << m_cur_draw_call_info.instance_count << ")";
+
+    return s.str();
+}
+
 //--------------------------------------------------------------------------------------------------
 void GfxrVulkanCommandHierarchyCreator::OnCommand(
 const DiveAnnotationProcessor::VulkanCommandInfo &vk_cmd_info,
@@ -65,7 +96,7 @@ std::vector<uint64_t>                            &render_pass_draw_call_counts)
         uint64_t cmd_buffer_index = AddNode(NodeType::kGfxrVulkanBeginCommandBufferNode,
                                             vk_cmd_string_stream.str());
         m_cur_command_buffer_node_index = cmd_buffer_index;
-        GetArgs(vulkan_cmd_args, m_cur_command_buffer_node_index, "");
+        GetArgs(vulkan_cmd_args, m_cur_command_buffer_node_index);
         AddChild(CommandHierarchy::TopologyType::kAllEventTopology,
                  m_cur_submit_node_index,
                  cmd_buffer_index);
@@ -75,7 +106,7 @@ std::vector<uint64_t>                            &render_pass_draw_call_counts)
         uint64_t cmd_buffer_index = AddNode(NodeType::kGfxrVulkanEndCommandBufferNode,
                                             vk_cmd_string_stream.str());
 
-        GetArgs(vulkan_cmd_args, cmd_buffer_index, "");
+        GetArgs(vulkan_cmd_args, cmd_buffer_index);
         AddChild(CommandHierarchy::TopologyType::kAllEventTopology,
                  m_cur_command_buffer_node_index,
                  cmd_buffer_index);
@@ -87,7 +118,7 @@ std::vector<uint64_t>                            &render_pass_draw_call_counts)
         uint64_t
         begin_debug_utils_label_cmd_index = AddNode(NodeType::kGfxrBeginDebugUtilsLabelCommandNode,
                                                     label_name.c_str());
-        GetArgs(vulkan_cmd_args, begin_debug_utils_label_cmd_index, "");
+        GetArgs(vulkan_cmd_args, begin_debug_utils_label_cmd_index);
         ConditionallyAddChild(begin_debug_utils_label_cmd_index);
         m_cur_parent_node_index_stack.push(begin_debug_utils_label_cmd_index);
     }
@@ -104,10 +135,23 @@ std::vector<uint64_t>                            &render_pass_draw_call_counts)
     else if (vulkan_cmd_name.find("vkCmdDraw") != std::string::npos ||
              vulkan_cmd_name.find("vkCmdDispatch") != std::string::npos)
     {
+        m_cur_draw_call_info = {};
+
         uint64_t vk_cmd_index = AddNode(NodeType::kGfxrVulkanDrawCommandNode,
                                         vk_cmd_string_stream.str());
-        GetArgs(vulkan_cmd_args, vk_cmd_index, "");
+        GetArgs(vulkan_cmd_args, vk_cmd_index);
         ConditionallyAddChild(vk_cmd_index);
+
+        if (vulkan_cmd_name.find("vkCmdDraw") != std::string::npos)
+        {
+            std::string extra_info = GetCurrDrawCallString();
+            if (!extra_info.empty())
+            {
+                // Update the draw node description with info obtained from its args
+                vk_cmd_string_stream << extra_info;
+                m_command_hierarchy.SetNodeDesc(vk_cmd_index, vk_cmd_string_stream.str());
+            }
+        }
     }
     else if (vulkan_cmd_name.find("vkCmdBeginRenderPass") != std::string::npos)
     {
@@ -119,15 +163,15 @@ std::vector<uint64_t>                            &render_pass_draw_call_counts)
         vk_cmd_string_stream << ", Draw Call Count: " << draw_call_count;
         uint64_t vk_cmd_index = AddNode(NodeType::kGfxrVulkanBeginRenderPassCommandNode,
                                         vk_cmd_string_stream.str());
-        GetArgs(vulkan_cmd_args, vk_cmd_index, "");
+        GetArgs(vulkan_cmd_args, vk_cmd_index);
         ConditionallyAddChild(vk_cmd_index);
         m_cur_parent_node_index_stack.push(vk_cmd_index);
     }
     else if (vulkan_cmd_name.find("vkCmdEndRenderPass") != std::string::npos)
     {
         uint64_t vk_cmd_index = AddNode(NodeType::kGfxrVulkanEndRenderPassCommandNode,
                                         vk_cmd_string_stream.str());
-        GetArgs(vulkan_cmd_args, vk_cmd_index, "");
+        GetArgs(vulkan_cmd_args, vk_cmd_index);
         ConditionallyAddChild(vk_cmd_index);
         if (!m_cur_parent_node_index_stack.empty())
         {
@@ -139,7 +183,7 @@ std::vector<uint64_t>                            &render_pass_draw_call_counts)
     {
         uint64_t vk_cmd_index = AddNode(NodeType::kGfxrVulkanCommandNode,
                                         vk_cmd_string_stream.str());
-        GetArgs(vulkan_cmd_args, vk_cmd_index, "");
+        GetArgs(vulkan_cmd_args, vk_cmd_index);
         ConditionallyAddChild(vk_cmd_index);
     }
 }
@@ -238,15 +282,12 @@ uint64_t GfxrVulkanCommandHierarchyCreator::AddNode(NodeType type, std::string &
         uint64_t local_node_index = m_node_children[CommandHierarchy::kAllEventTopology].size();
         m_dive_indices_to_local_indices_map[node_index] = local_node_index;
         m_node_children[CommandHierarchy::kAllEventTopology].resize(local_node_index + 1);
-        m_node_root_node_indices[CommandHierarchy::kAllEventTopology].resize(local_node_index + 1);
     }
     else
     {
         DIVE_ASSERT(m_node_children[CommandHierarchy::kAllEventTopology].size() == node_index);
         m_node_children[CommandHierarchy::kAllEventTopology].resize(
         m_node_children[CommandHierarchy::kAllEventTopology].size() + 1);
-        m_node_root_node_indices[CommandHierarchy::kAllEventTopology].resize(
-        m_node_root_node_indices[CommandHierarchy::kAllEventTopology].size() + 1);
     }
 
     return node_index;
@@ -274,9 +315,46 @@ void GfxrVulkanCommandHierarchyCreator::AddChild(CommandHierarchy::TopologyType
     }
 }
 
+bool GfxrVulkanCommandHierarchyCreator::ParseCurDrawCallInfo(std::string_view key,
+                                                             std::string_view val)
+{
+    if (key == "indexCount")
+    {
+        uint64_t value = 0;
+        if (!absl::SimpleAtoi(val, &value))
+        {
+            return false;
+        }
+        m_cur_draw_call_info.index_count = value;
+        return true;
+    }
+    if (key == "vertexCount")
+    {
+        uint64_t value = 0;
+        if (!absl::SimpleAtoi(val, &value))
+        {
+            return false;
+        }
+        m_cur_draw_call_info.vertex_count = value;
+        return true;
+    }
+    if (key == "instanceCount")
+    {
+        uint64_t value = 0;
+        if (!absl::SimpleAtoi(val, &value))
+        {
+            return false;
+        }
+        m_cur_draw_call_info.instance_count = value;
+        return true;
+    }
+
+    // key is unrelated to DrawCallDescInfo
+    return true;
+}
+
 void GfxrVulkanCommandHierarchyCreator::GetArgs(const nlohmann::ordered_json &json_args,
-                                                uint64_t                      curr_index,
-                                                const std::string            &current_path)
+                                                uint64_t                      curr_index)
 {
     // This block processes key-value pairs where keys represent field names
     // and values can be objects, arrays, or primitives.
@@ -294,7 +372,7 @@ void GfxrVulkanCommandHierarchyCreator::GetArgs(const nlohmann::ordered_json &js
                          curr_index,
                          object_node_index);
 
-                GetArgs(val, object_node_index, "");
+                GetArgs(val, object_node_index);
             }
             else if (val.is_array())
             {
@@ -311,7 +389,7 @@ void GfxrVulkanCommandHierarchyCreator::GetArgs(const nlohmann::ordered_json &js
                     if (element.is_object())
                     {
                         // If an array element is an object, recursively process it.
-                        GetArgs(element, array_node_index, "");
+                        GetArgs(element, array_node_index);
                     }
                     else if (element.is_array())
                     {
@@ -323,7 +401,7 @@ void GfxrVulkanCommandHierarchyCreator::GetArgs(const nlohmann::ordered_json &js
                         AddChild(CommandHierarchy::TopologyType::kAllEventTopology,
                                  array_node_index,
                                  nested_array_node_index);
-                        GetArgs(element, nested_array_node_index, "");
+                        GetArgs(element, nested_array_node_index);
                     }
                     else
                     {
@@ -341,12 +419,26 @@ void GfxrVulkanCommandHierarchyCreator::GetArgs(const nlohmann::ordered_json &js
             }
             else
             {
+                std::ostringstream s;
+                std::string        val_str;
+
+                s.str("");
+                s << val;
+                val_str = s.str();
+
+                s.str("");
+                s << key << ":" << val;
+
+                if (!ParseCurDrawCallInfo(key, val_str))
+                {
+                    std::cerr << "GfxrVulkanCommandHierarchyCreator::GetArgs() "
+                              << "could not parse draw call info from: " << s.str() << std::endl;
+                }
+
                 // If the value is a primitive,
                 // create a node containing the "key:value" pair.
-                std::ostringstream vk_cmd_arg_string_stream;
-                vk_cmd_arg_string_stream << key << ":" << val;
-                uint64_t vk_cmd_arg_index = AddNode(NodeType::kGfxrVulkanCommandArgNode,
-                                                    vk_cmd_arg_string_stream.str());
+
+                uint64_t vk_cmd_arg_index = AddNode(NodeType::kGfxrVulkanCommandArgNode, s.str());
                 AddChild(CommandHierarchy::TopologyType::kAllEventTopology,
                          curr_index,
                          vk_cmd_arg_index);
@@ -363,7 +455,7 @@ void GfxrVulkanCommandHierarchyCreator::GetArgs(const nlohmann::ordered_json &js
             {
                 // If an array element is an object or another array,
                 // recursively process it, and associate it with the current parent node.
-                GetArgs(element, curr_index, "");
+                GetArgs(element, curr_index);
             }
             else
             {
diff --git a/dive_core/gfxr_vulkan_command_hierarchy.h b/dive_core/gfxr_vulkan_command_hierarchy.h
@@ -59,15 +59,24 @@ class GfxrVulkanCommandHierarchyCreator
     void ClearCreatedDiveIndices() { m_dive_indices_to_local_indices_map.clear(); }
 
 private:
-    void     GetArgs(const nlohmann::ordered_json &j,
-                     uint64_t                      curr_index,
-                     const std::string            &current_path = "");
-    void     CreateTopologies();
+    // Helper function to parse json representation of GFXR file into nodes and make calls to
+    // AddNode() and AddChild() in hiearachical order.
+    void GetArgs(const nlohmann::ordered_json &json_args, uint64_t curr_index);
+
+    void CreateTopologies();
+
+    // Wrapper for m_command_hierarchy.AddNode(), returns the command buffer index representing this
+    // node's place in m_command_hierarchy.m_node_type DiveVector.
+    //
+    // Also may add node to m_dive_indices_to_local_indices_map and reserve space in m_node_children
+    // for future appends
     uint64_t AddNode(NodeType type, std::string &&desc);
-    void     AddChild(CommandHierarchy::TopologyType type,
-                      uint64_t                       node_index,
-                      uint64_t                       child_node_index);
-    void     ConditionallyAddChild(uint64_t node_index);
+
+    // Updates m_node_children
+    void AddChild(CommandHierarchy::TopologyType type,
+                  uint64_t                       node_index,
+                  uint64_t                       child_node_index);
+    void ConditionallyAddChild(uint64_t node_index);
 
     uint64_t               m_cur_submit_node_index = 0;
     uint64_t               m_cur_command_buffer_node_index = 0;
@@ -76,10 +85,31 @@ class GfxrVulkanCommandHierarchyCreator
     const GfxrCaptureData &m_capture_data;
     // This is a list of child indices per node, ie. topology info
     // Once parsing is complete, we will create a topology from this
-    DiveVector<DiveVector<uint64_t>> m_node_children[CommandHierarchy::kTopologyTypeCount];
-    DiveVector<uint64_t>             m_node_root_node_indices[CommandHierarchy::kTopologyTypeCount];
-    Topology                         m_topology[CommandHierarchy::kTopologyTypeCount];
-    bool                             m_used_in_mixed_command_hierarchy = false;
+    DiveVector<DiveVector<uint64_t>>       m_node_children[CommandHierarchy::kTopologyTypeCount];
+    Topology                               m_topology[CommandHierarchy::kTopologyTypeCount];
+    bool                                   m_used_in_mixed_command_hierarchy = false;
     std::unordered_map<uint64_t, uint64_t> m_dive_indices_to_local_indices_map;
+
+    // Additional info that will be displayed in the description of a draw call node
+    struct DrawCallDescInfo
+    {
+        uint64_t index_count = 0;
+        uint64_t vertex_count = 0;
+        uint64_t instance_count = 0;
+    };
+
+    // Returns false if key was recognized to correspond to a DrawCallDescInfo field but val could
+    // not be parsed
+    bool ParseCurDrawCallInfo(std::string_view key, std::string_view val);
+
+    // Forms string of drawcall info, some examples:
+    //
+    // vkCmdDraw: "(vertexCount=#,instanceCount=#)"
+    // vkCmdDrawIndexed: "(indexCount=#,instanceCount=#)"
+    // vkCmdDrawMultiEXT: "(instanceCount=#)"
+    // vkCmdDraw* without instanceCount parameter: ""
+    std::string GetCurrDrawCallString();
+
+    DrawCallDescInfo m_cur_draw_call_info;
 };
 }  // namespace Dive

Original file line number	Diff line number	Diff line change
`@@ -240,6 +240,14 @@ const char *CommandHierarchy::GetNodeDesc(uint64_t node_index) const`
`240`	`240`	`return m_nodes.m_description[node_index].c_str();`
`241`	`241`	`}`
`242`	`242`
	`243`	`+//--------------------------------------------------------------------------------------------------`
	`244`	`+void CommandHierarchy::SetNodeDesc(uint64_t node_index, const std::string &desc)`
	`245`	`+{`
	`246`	`+ DIVE_ASSERT(node_index < m_nodes.m_description.size());`
	`247`	`+ m_nodes.m_description[node_index] = desc;`
	`248`	`+ return;`
	`249`	`+}`
	`250`	`+`
`243`	`251`	`//--------------------------------------------------------------------------------------------------`
`244`	`252`	`Dive::EngineType CommandHierarchy::GetSubmitNodeEngineType(uint64_t node_index) const`
`245`	`253`	`{`