Improve rocprof-sys-avail to report VCN and JPEG metrics on supported devices (#226)

* SWDEV-535445: rocprof-sys-avail shows jpeg_activity even when unsupported

* Added vcn tracking

* jpeg and vcn description now includes supported gpus

* Add getter methods per device to check vcn and jpeg support

Add logic to check if vcn activity and vcn busy values are supported for each device.
Add logic to check if jpeg activity and jpeg busy values are supported for each device.

Co-authored-by: Sajina P Kandy <sputhala@amd.com>

* Add getter methods per device to check vcn and jpeg support (#228)

* Formatting

* Variable fix

* List of supported GPUs are now ordered

* Removed the ability to see which gpu supports jpeg and vcn activity to reduce clutter

* Formatting

* Testing for busy support

* jpeg and vcn only show if supported

* Removed commented code

* Formatting

* Applied amd_smi cpp/hpp fixes

* Added break condition for xcp loop

* Modified loops for efficiency

* Removed unneccessary macro

* Removed unneccessary includes

---------

Co-authored-by: Sajina Kandy <sputhala@amd.com>
Co-authored-by: Sajina PK <Sajina.PuthalathKandy@amd.com>

source/lib/core/gpu.cpp

@@ -201,8 +201,12 @@ add_device_metadata()
  * Required amdsmi methods to get processors and handles
  */
 
-uint32_t                             processors::total_processor_count = 0;
-std::vector<amdsmi_processor_handle> processors::processors_list       = {};
+uint32_t                             processors::total_processor_count   = 0;
+std::vector<amdsmi_processor_handle> processors::processors_list         = {};
+std::vector<bool>                    processors::vcn_activity_supported  = {};
+std::vector<bool>                    processors::jpeg_activity_supported = {};
+std::vector<bool>                    processors::vcn_busy_supported      = {};
+std::vector<bool>                    processors::jpeg_busy_supported     = {};
 
 void
 get_processor_handles()
@@ -246,10 +250,87 @@ get_processor_handles()
                 return;
             }
             processors::processors_list.push_back(processor);
+
+            amdsmi_gpu_metrics_t gpu_metrics;
+            bool                 vcn_supported    = false;
+            bool                 jpeg_supported   = false;
+            bool                 v_busy_supported = false;
+            bool                 j_busy_supported = false;
+            ret = amdsmi_get_gpu_metrics_info(processor, &gpu_metrics);
+            if(ret == AMDSMI_STATUS_SUCCESS)
+            {
+                for(const auto& vcn_activity : gpu_metrics.vcn_activity)
+                {
+                    if(vcn_activity != UINT16_MAX)
+                    {
+                        vcn_supported = true;
+                        break;
+                    }
+                }
+                for(const auto& jpeg_activity : gpu_metrics.jpeg_activity)
+                {
+                    if(jpeg_activity != UINT16_MAX)
+                    {
+                        jpeg_supported = true;
+                        break;
+                    }
+                }
+                for(const auto& xcp : gpu_metrics.xcp_stats)
+                {
+                    if(!v_busy_supported)
+                    {
+                        v_busy_supported =
+                            std::any_of(std::begin(xcp.vcn_busy), std::end(xcp.vcn_busy),
+                                        [](uint16_t val) { return val != UINT16_MAX; });
+                    }
+
+                    if(!j_busy_supported)
+                    {
+                        j_busy_supported = std::any_of(
+                            std::begin(xcp.jpeg_busy), std::end(xcp.jpeg_busy),
+                            [](uint16_t val) { return val != UINT16_MAX; });
+                    }
+
+                    if(v_busy_supported && j_busy_supported) break;
+                }
+            }
+            processors::vcn_activity_supported.push_back(vcn_supported);
+            processors::jpeg_activity_supported.push_back(jpeg_supported);
+            processors::vcn_busy_supported.push_back(v_busy_supported);
+            processors::jpeg_busy_supported.push_back(j_busy_supported);
         }
     }
     processors::total_processor_count = processors::processors_list.size();
 }
+
+bool
+is_vcn_activity_supported(uint32_t dev_id)
+{
+    if(dev_id >= processors::vcn_activity_supported.size()) return false;
+    return processors::vcn_activity_supported[dev_id];
+}
+
+bool
+is_jpeg_activity_supported(uint32_t dev_id)
+{
+    if(dev_id >= processors::jpeg_activity_supported.size()) return false;
+    return processors::jpeg_activity_supported[dev_id];
+}
+
+bool
+is_vcn_busy_supported(uint32_t dev_id)
+{
+    if(dev_id >= processors::vcn_busy_supported.size()) return false;
+    return processors::vcn_busy_supported[dev_id];
+}
+
+bool
+is_jpeg_busy_supported(uint32_t dev_id)
+{
+    if(dev_id >= processors::jpeg_busy_supported.size()) return false;
+    return processors::jpeg_busy_supported[dev_id];
+}
+
 uint32_t
 get_processor_count()
 {