Add kernel selection table

CMakeLists.txt

@@ -135,6 +135,8 @@ list(APPEND VIEW_FILES
     src/view/src/compute/rocprofvis_compute_workload_view.cpp
     src/view/src/widgets/rocprofvis_compute_widget.cpp
     src/view/src/widgets/rocprofvis_query_builder.cpp
+    src/view/src/compute/rocprofvis_compute_kernel_metric_table.cpp
+    src/view/src/compute/rocprofvis_compute_tester.cpp
 )
 endif(COMPUTE_UI_SUPPORT)
 

src/controller/src/compute/rocprofvis_controller_trace_compute.cpp

@@ -278,14 +278,16 @@ rocprofvis_result_t ComputeTrace::AsyncFetch(Arguments& args, Future& future, Me
         result = args.GetUInt64(kRPVControllerMetricArgsNumKernels, 0, &num_entries);
         if(result == kRocProfVisResultSuccess)
         {
+            auto query_args = std::make_shared<QueryArgumentStore>();
+            auto query_out = std::make_shared<QueryDataStore>();
+
             uint64_t uint64_data = 0;
-            m_query_arguments.clear();
             for(uint64_t i = 0; i < num_entries; i++)
             {
                 result = args.GetUInt64(kRPVControllerMetricArgsKernelIdIndexed, i, &uint64_data);
                 if(result == kRocProfVisResultSuccess)
                 {
-                    m_query_arguments.emplace_back(kRPVComputeParamKernelId, std::to_string(uint64_data));
+                    query_args->emplace_back(kRPVComputeParamKernelId, std::to_string(uint64_data));
                 } 
                 else
                 {
@@ -313,7 +315,7 @@ rocprofvis_result_t ComputeTrace::AsyncFetch(Arguments& args, Future& future, Me
                                     metric_id.SetEntryID((uint32_t)uint64_data);                                   
                                 }
                             }
-                            m_query_arguments.emplace_back(kRPVComputeParamMetricId, metric_id.ToString());
+                            query_args->emplace_back(kRPVComputeParamMetricId, metric_id.ToString());
                             result = kRocProfVisResultSuccess;
                         }
                         else
@@ -325,9 +327,9 @@ rocprofvis_result_t ComputeTrace::AsyncFetch(Arguments& args, Future& future, Me
             }
             if(result == kRocProfVisResultSuccess)
             {
-                future.Set(JobSystem::Get().IssueJob([this, &output](Future* future) -> rocprofvis_result_t {
+                future.Set(JobSystem::Get().IssueJob([this, &output, query_args, query_out](Future* future) -> rocprofvis_result_t {
                     rocprofvis_result_t result = kRocProfVisResultUnknownError;
-                    m_query_output = { 
+                    *query_out = { 
                         { 
                             { kRPVComputeColumnMetricId, std::nullopt },
                             { kRPVComputeColumnMetricName, std::nullopt },
@@ -338,7 +340,7 @@ rocprofvis_result_t ComputeTrace::AsyncFetch(Arguments& args, Future& future, Me
                         {} 
                     };
                     rocprofvis_dm_database_t db = rocprofvis_dm_get_property_as_handle(m_dm_handle, kRPVDMDatabaseHandle, 0);
-                    rocprofvis_dm_result_t dm_result = ExecuteQuery(db, m_dm_handle, nullptr, future, kRPVComputeFetchMetricValues, m_query_arguments, m_query_output, [this, &output](const QueryDataStore& data_store){
+                    rocprofvis_dm_result_t dm_result = ExecuteQuery(db, m_dm_handle, nullptr, future, kRPVComputeFetchMetricValues, *query_args, *query_out, [this, &output](const QueryDataStore& data_store){
                         uint64_t valid_results = 0;
                         rocprofvis_property_t property;
                         rocprofvis_controller_primitive_type_t type;

src/controller/src/rocprofvis_controller.cpp

@@ -361,25 +361,37 @@ rocprofvis_result_t rocprofvis_controller_table_fetch_async(
     rocprofvis_controller_array_t* output)
 {
     rocprofvis_result_t error = kRocProfVisResultInvalidArgument;
-    RocProfVis::Controller::SystemTraceRef system_trace(controller);
-#ifdef COMPUTE_UI_SUPPORT
-    RocProfVis::Controller::ComputeTraceRef compute_trace(controller);
-#endif
+
+    // Determine actual controller type first to avoid ambiguous reference validation
+    rocprofvis_controller_object_type_t controller_type;
+    if(rocprofvis_controller_get_object_type(controller, &controller_type) != kRocProfVisResultSuccess)
+    {
+        return error;
+    }
+
     RocProfVis::Controller::TableRef table_ref(table);
     RocProfVis::Controller::ArgumentsRef args_ref(args);
     RocProfVis::Controller::FutureRef future(result);
     RocProfVis::Controller::ArrayRef array(output);
 
     if (table_ref.IsValid() && args_ref.IsValid() && future.IsValid() && array.IsValid())
     {
-        if (system_trace.IsValid())
+        if (controller_type == kRPVControllerObjectTypeControllerSystem)
         {
-            error = system_trace->AsyncFetch(*table_ref, *args_ref, *future, *array);
+            RocProfVis::Controller::SystemTraceRef system_trace(controller);
+            if(system_trace.IsValid())
+            {
+                error = system_trace->AsyncFetch(*table_ref, *args_ref, *future, *array);
+            }
         }
 #ifdef COMPUTE_UI_SUPPORT
-        else if (compute_trace.IsValid())
+        else if (controller_type == kRPVControllerObjectTypeControllerCompute)
         {
-            error = compute_trace->AsyncFetch(*table_ref, *args_ref, *future, *array);
+            RocProfVis::Controller::ComputeTraceRef compute_trace(controller);
+            if(compute_trace.IsValid())
+            {
+                error = compute_trace->AsyncFetch(*table_ref, *args_ref, *future, *array);
+            }
         }
 #endif
     }

src/model/src/database/rocprofvis_db_compute.cpp

@@ -295,6 +295,9 @@ namespace DataModel
                 {
                     std::string metric_id  = selector_str.substr(0, colon_pos);
                     std::string value_name = selector_str.substr(colon_pos + 1);
+                    // Convert value_name to lowercase to match SQL LOWER(value_name) comparison
+                    std::transform(value_name.begin(), value_name.end(), value_name.begin(),
+                                   [](unsigned char c) { return std::tolower(c); });
                     metric_selectors.push_back({ metric_id, value_name });
                 }
             }

src/view/src/compute/rocprofvis_compute_kernel_details.cpp

@@ -6,6 +6,7 @@
 #include "rocprofvis_compute_selection.h"
 #include "rocprofvis_data_provider.h"
 #include "rocprofvis_event_manager.h"
+#include "rocprofvis_compute_kernel_metric_table.h"
 
 #include "imgui.h"
 
@@ -20,13 +21,50 @@ ComputeKernelDetailsView::ComputeKernelDetailsView(
 , m_data_provider(data_provider)
 , m_memory_chart(data_provider, compute_selection)
 , m_roofline(nullptr)
+, m_kernel_metric_table(nullptr)
 , m_compute_selection(compute_selection)
+, m_client_id(IdGenerator::GetInstance().GenerateId())
 , m_sol_table(data_provider, compute_selection, METRIC_CAT_SOL, METRIC_TABLE_SOL)
+, m_workload_selection_changed_token(EventManager::InvalidSubscriptionToken)
+, m_kernel_selection_changed_token(EventManager::InvalidSubscriptionToken)
+, m_new_table_data_token(EventManager::InvalidSubscriptionToken)
+, m_metrics_fetched_token(EventManager::InvalidSubscriptionToken)
+{
+    SubscribeToEvents();
+
+    m_roofline = std::make_unique<RocProfVis::View::Roofline>(data_provider);
+    m_kernel_metric_table = std::make_unique<RocProfVis::View::KernelMetricTable>(data_provider, compute_selection);
+
+    m_widget_name = GenUniqueName("ComputeKernelDetailsView");
+}
+
+ComputeKernelDetailsView::~ComputeKernelDetailsView()
+{
+    EventManager::GetInstance()->Unsubscribe(
+        static_cast<int>(RocEvents::kComputeWorkloadSelectionChanged),
+        m_workload_selection_changed_token);
+    EventManager::GetInstance()->Unsubscribe(
+        static_cast<int>(RocEvents::kComputeKernelSelectionChanged),
+        m_kernel_selection_changed_token);
+    EventManager::GetInstance()->Unsubscribe(
+        static_cast<int>(RocEvents::kComputeMetricsFetched), m_metrics_fetched_token);
+    EventManager::GetInstance()->Unsubscribe(
+        static_cast<int>(RocEvents::kNewTableData), m_new_table_data_token);
+}
+
+void ComputeKernelDetailsView::SubscribeToEvents()
 {
     auto workload_changed_handler = [this](std::shared_ptr<RocEvent> e) {
         auto evt = std::dynamic_pointer_cast<ComputeSelectionChangedEvent>(e);
         if(evt && evt->GetSourceId() == m_data_provider.GetTraceFilePath())
         {
+            // Fetch pivot table data
+            if(m_kernel_metric_table)
+            {
+                //clear existing model table data
+                m_data_provider.ComputeModel().GetKernelSelectionTable().Clear();
+                m_kernel_metric_table->FetchData(evt->GetId());
+            }
             m_sol_table.Clear();
         }
     };
@@ -67,26 +105,33 @@ ComputeKernelDetailsView::ComputeKernelDetailsView(
             }
         }
     };
-
     m_metrics_fetched_token = EventManager::GetInstance()->Subscribe(
         static_cast<int>(RocEvents::kComputeMetricsFetched), metrics_fetched_handler);
 
-    m_roofline = std::make_unique<RocProfVis::View::Roofline>(data_provider);
+    // subscribe to fetch table data event 
+    auto new_table_data_handler = [this](std::shared_ptr<RocEvent> e) {
+        if(auto table_data_event = std::dynamic_pointer_cast<TableDataEvent>(e) )
+        {
+            if(m_data_provider.GetTraceFilePath() != table_data_event->GetSourceId())
+            {
+                return;
+            }
 
-    m_widget_name = GenUniqueName("ComputeKernelDetailsView");
-}
+            if(table_data_event->GetResponseCode() != kRocProfVisResultSuccess)
+            {
+                return;
+            }
 
-ComputeKernelDetailsView::~ComputeKernelDetailsView()
-{
-    EventManager::GetInstance()->Unsubscribe(
-        static_cast<int>(RocEvents::kComputeWorkloadSelectionChanged),
-        m_workload_selection_changed_token);
-    EventManager::GetInstance()->Unsubscribe(
-        static_cast<int>(RocEvents::kComputeKernelSelectionChanged),
-        m_kernel_selection_changed_token);
-    EventManager::GetInstance()->Unsubscribe(
-        static_cast<int>(RocEvents::kComputeMetricsFetched), m_metrics_fetched_token);
-}
+            if(table_data_event->GetRequestID() == DataProvider::METRIC_PIVOT_TABLE_REQUEST_ID)
+            {
+                m_kernel_metric_table->HandleNewData();
+            }
+        }
+    };
+
+    m_new_table_data_token = EventManager::GetInstance()->Subscribe(
+        static_cast<int>(RocEvents::kNewTableData), new_table_data_handler);
+}   
 
 void
 ComputeKernelDetailsView::Update()
@@ -95,13 +140,24 @@ ComputeKernelDetailsView::Update()
     {
         m_roofline->Update();
     }
+    if(m_kernel_metric_table)
+    {
+        m_kernel_metric_table->Update();
+    }
 }
 
 void
 ComputeKernelDetailsView::Render()
 {
     ImGui::BeginChild("kernel_details");
+
+    if(m_kernel_metric_table)
+    {
+        m_kernel_metric_table->Render();
+    }
+
     ImGui::Text("Memory Chart");
+
     m_memory_chart.Render();
     m_sol_table.Render();
     if(m_roofline)

src/view/src/compute/rocprofvis_compute_kernel_details.h

@@ -15,6 +15,7 @@ namespace View
 class DataProvider;
 class ComputeSelection;
 class Roofline;
+class KernelMetricTable;
 
 class ComputeKernelDetailsView : public RocWidget
 {
@@ -27,16 +28,23 @@ class ComputeKernelDetailsView : public RocWidget
     void Update() override;
 
 private:
+
+    void SubscribeToEvents();
+
     DataProvider&          m_data_provider;
     ComputeMemoryChartView m_memory_chart;
 
     std::shared_ptr<ComputeSelection> m_compute_selection;
     std::unique_ptr<Roofline>         m_roofline;
+    std::unique_ptr<KernelMetricTable> m_kernel_metric_table;
+
+    uint64_t m_client_id;
     MetricTableWidget                 m_sol_table;
 
     EventManager::SubscriptionToken m_workload_selection_changed_token;
     EventManager::SubscriptionToken m_kernel_selection_changed_token;
     EventManager::SubscriptionToken m_metrics_fetched_token;
+    EventManager::SubscriptionToken m_new_table_data_token;
 };
 
 }  // namespace View