PC Sampling: Create PC Sampling interfaces

Create new interface group for PC Sampling

Change-Id: I59b4cfe9f8d1ae313dc28be1d2ed49f750d8212b

runtime/hsa-runtime/core/inc/amd_gpu_agent.h

@@ -59,6 +59,7 @@
 #include "core/util/small_heap.h"
 #include "core/util/locks.h"
 #include "core/util/lazy_ptr.h"
+#include "pcs/pcs_runtime.h"
 
 namespace rocr {
 namespace AMD {

runtime/hsa-runtime/core/inc/hsa_api_trace_int.h

@@ -53,6 +53,7 @@ namespace core {
     static const uint32_t HSA_EXT_FINALIZER_API_TABLE_ID = 0;
     static const uint32_t HSA_EXT_IMAGE_API_TABLE_ID = 1;
     static const uint32_t HSA_EXT_AQLPROFILE_API_TABLE_ID = 2;
+    static const uint32_t HSA_EXT_PC_SAMPLING_API_TABLE_ID = 3;
 
     ::HsaApiTable hsa_api;
     ::CoreApiTable core_api;
@@ -60,6 +61,7 @@ namespace core {
     ::FinalizerExtTable finalizer_api;
     ::ImageExtTable image_api;
     ::ToolsApiTable tools_api;
+    ::PcSamplingExtTable pcs_api;
 
     HsaApiTable();
     void Init();

runtime/hsa-runtime/core/inc/hsa_ext_interface.h

@@ -57,12 +57,17 @@ struct ImageExtTableInternal : public ImageExtTable {
   decltype(::hsa_amd_image_get_info_max_dim)* hsa_amd_image_get_info_max_dim_fn;
 };
 
+struct PcSamplingExtTableInternal : public PcSamplingExtTable {};
+
 class ExtensionEntryPoints {
  public:
 
   // Table of function pointers for Hsa Extension Image
   ImageExtTableInternal image_api;
 
+  // Table of function pointers for Hsa vendor PC Sampling
+  PcSamplingExtTableInternal pcs_api;
+
   // Table of function pointers for Hsa Extension Finalizer
   FinalizerExtTable finalizer_api;
 
@@ -77,6 +82,12 @@ class ExtensionEntryPoints {
   // Reset Api tables to point to null implementations
   void UnloadImage();
 
+  // Update PC Sampling Api table with handles to implementation
+  void LoadPcSampling();
+
+  // Reset PC Sampling tables to point to null implementations
+  void UnloadPcSampling();
+
  private:
   typedef void (*Load_t)(const ::HsaApiTable* table);
   typedef void (*Unload_t)();
@@ -89,6 +100,9 @@ class ExtensionEntryPoints {
   // Initialize table for HSA Image Extension Api's
   void InitImageExtTable();
 
+  // Initialize table for HSA PC Sampling Extension Api's
+  void InitPcSamplingExtTable();
+
   // Initialize Amd Ext table for Api related to Images
   void InitAmdExtTable();
 
@@ -96,7 +110,7 @@ class ExtensionEntryPoints {
   void UpdateAmdExtTable(decltype(::hsa_amd_image_create)* func_ptr);
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionEntryPoints);
-};  
+};
 }   //  namespace core
 }   //  namespace rocr
 

runtime/hsa-runtime/core/runtime/amd_gpu_agent.cpp

@@ -1309,6 +1309,10 @@ hsa_status_t GpuAgent::GetInfo(hsa_agent_info_t attribute, void* value) const {
         setFlag(HSA_EXTENSION_IMAGES);
       }
 
+      if (core::hsa_internal_api_table_.pcs_api.hsa_ven_amd_pcs_iterate_configuration_fn != NULL) {
+        setFlag(HSA_EXTENSION_AMD_PC_SAMPLING);
+      }
+
       if (os::LibHandle lib = os::LoadLib(kAqlProfileLib)) {
         os::CloseLib(lib);
         setFlag(HSA_EXTENSION_AMD_AQLPROFILE);

runtime/hsa-runtime/core/runtime/hsa.cpp

@@ -343,7 +343,8 @@ static size_t get_extension_table_length(uint16_t extension, uint16_t major, uin
       {"hsa_ven_amd_loader_1_01_pfn_t", sizeof(hsa_ven_amd_loader_1_01_pfn_t)},
       {"hsa_ven_amd_loader_1_02_pfn_t", sizeof(hsa_ven_amd_loader_1_02_pfn_t)},
       {"hsa_ven_amd_loader_1_03_pfn_t", sizeof(hsa_ven_amd_loader_1_03_pfn_t)},
-      {"hsa_ven_amd_aqlprofile_1_00_pfn_t", sizeof(hsa_ven_amd_aqlprofile_1_00_pfn_t)}};
+      {"hsa_ven_amd_aqlprofile_1_00_pfn_t", sizeof(hsa_ven_amd_aqlprofile_1_00_pfn_t)},
+      {"hsa_ven_amd_pc_sampling_1_00_pfn_t", sizeof(hsa_ven_amd_pc_sampling_1_00_pfn_t)}};
   static const size_t num_tables = sizeof(sizes) / sizeof(sizes_t);
 
   if (minor > 99) return 0;
@@ -372,6 +373,9 @@ static size_t get_extension_table_length(uint16_t extension, uint16_t major, uin
     case HSA_EXTENSION_AMD_AQLPROFILE:
       name = "hsa_ven_amd_aqlprofile_";
       break;
+    case HSA_EXTENSION_AMD_PC_SAMPLING:
+      name = "hsa_ven_amd_pc_sampling_";
+      break;
     default:
       return 0;
   }
@@ -429,6 +433,21 @@ hsa_status_t hsa_system_get_major_extension_table(uint16_t extension, uint16_t v
     return HSA_STATUS_SUCCESS;
   }
 
+  if (extension == HSA_EXTENSION_AMD_PC_SAMPLING) {
+    if (version_major != core::Runtime::runtime_singleton_->extensions_.pcs_api.version.major_id) {
+      return HSA_STATUS_ERROR;
+    }
+    hsa_ven_amd_pc_sampling_1_00_pfn_t ext_table;
+    ext_table.hsa_ven_amd_pcs_create = hsa_ven_amd_pcs_create;
+    ext_table.hsa_ven_amd_pcs_create_from_id = hsa_ven_amd_pcs_create_from_id;
+    ext_table.hsa_ven_amd_pcs_destroy = hsa_ven_amd_pcs_destroy;
+    ext_table.hsa_ven_amd_pcs_start = hsa_ven_amd_pcs_start;
+    ext_table.hsa_ven_amd_pcs_stop = hsa_ven_amd_pcs_stop;
+    ext_table.hsa_ven_amd_pcs_flush = hsa_ven_amd_pcs_flush;
+
+    memcpy(table, &ext_table, Min(sizeof(ext_table), table_length));
+  }
+
   if (extension == HSA_EXTENSION_FINALIZER) {
     if (version_major !=
         core::Runtime::runtime_singleton_->extensions_.finalizer_api.version.major_id) {

runtime/hsa-runtime/core/runtime/hsa_api_trace.cpp

@@ -84,6 +84,7 @@ void HsaApiTable::Init() {
   constexpr size_t expected_image_ext_table_size = 120;
   constexpr size_t expected_finalizer_ext_table_size = 64;
   constexpr size_t expected_tools_table_size = 64;
+  constexpr size_t expected_pc_sampling_ext_table_size = 72;
 
   static_assert(sizeof(CoreApiTable) == expected_core_api_table_size,
                 "HSA core API table size changed, bump HSA_CORE_API_TABLE_STEP_VERSION and set "
@@ -101,6 +102,9 @@ void HsaApiTable::Init() {
   static_assert(sizeof(ToolsApiTable) == expected_tools_table_size,
                 "HSA tools table size changed, bump HSA_TOOLS_API_TABLE_STEP_VERSION "
                 "and set expected_tools_table_size to the new size of the struct");
+  static_assert(sizeof(PcSamplingExtTable) == expected_pc_sampling_ext_table_size,
+                "HSA finalizer ext table size changed, bump HSA_PC_SAMPLING_API_TABLE_STEP_VERSION "
+                "and set expected_pc_sampling_ext_table_size to the new size of the struct");
 
   // Initialize Version of Api Table
   hsa_api.version.major_id = HSA_API_TABLE_MAJOR_VERSION;
@@ -120,6 +124,7 @@ void HsaApiTable::Init() {
   // of Hsa Runtime initialization, including their major ids
   hsa_api.finalizer_ext_ = NULL;
   hsa_api.image_ext_ = NULL;
+  hsa_api.pc_sampling_ext_ = NULL;
 
   UpdateTools();
   hsa_api.tools_ = &tools_api;
@@ -146,6 +151,13 @@ void HsaApiTable::CloneExts(void* ext_table, uint32_t table_id) {
     hsa_api.image_ext_ = &image_api;
     return;
   }
+
+  // Update HSA Extension PC Sampling Api table
+  if (table_id == HSA_EXT_PC_SAMPLING_API_TABLE_ID) {
+    pcs_api = *reinterpret_cast<PcSamplingExtTable*>(ext_table);
+    hsa_api.pc_sampling_ext_ = &pcs_api;
+    return;
+  }
 }
 
 void HsaApiTable::LinkExts(void* ext_table, uint32_t table_id) {
@@ -165,6 +177,13 @@ void HsaApiTable::LinkExts(void* ext_table, uint32_t table_id) {
     hsa_api.image_ext_ = reinterpret_cast<ImageExtTable*>(ext_table);
     return;
   }
+
+  // Update HSA Extension PC Sampling Api table
+  if (table_id == HSA_EXT_PC_SAMPLING_API_TABLE_ID) {
+    pcs_api = *reinterpret_cast<PcSamplingExtTable*>(ext_table);
+    hsa_api.pc_sampling_ext_ = &pcs_api;
+    return;
+  }
 }
 
 // Update Api table for Hsa Core Runtime

runtime/hsa-runtime/core/runtime/hsa_ext_interface.cpp

@@ -41,6 +41,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 #include "image/inc/hsa_ext_image_impl.h"
+#include "pcs/inc/hsa_ven_amd_pc_sampling_impl.h"
 #include "core/inc/hsa_ext_interface.h"
 #include "core/inc/runtime.h"
 
@@ -56,6 +57,7 @@ namespace core {
 ExtensionEntryPoints::ExtensionEntryPoints() {
   InitFinalizerExtTable();
   InitImageExtTable();
+  InitPcSamplingExtTable();
   InitAmdExtTable();
 }
 
@@ -99,6 +101,22 @@ void ExtensionEntryPoints::InitImageExtTable() {
   image_api.hsa_ext_image_create_with_layout_fn = hsa_ext_null;
 }
 
+// Initialize PC Sampling function table to be NULLs
+void ExtensionEntryPoints::InitPcSamplingExtTable() {
+  // Initialize Version of Api Table
+  pcs_api.version.major_id = 0x00;
+  pcs_api.version.minor_id = 0x00;
+  pcs_api.version.step_id = 0x00;
+
+  pcs_api.hsa_ven_amd_pcs_iterate_configuration_fn = hsa_ext_null;
+  pcs_api.hsa_ven_amd_pcs_create_fn = hsa_ext_null;
+  pcs_api.hsa_ven_amd_pcs_create_from_id_fn = hsa_ext_null;
+  pcs_api.hsa_ven_amd_pcs_destroy_fn = hsa_ext_null;
+  pcs_api.hsa_ven_amd_pcs_start_fn = hsa_ext_null;
+  pcs_api.hsa_ven_amd_pcs_stop_fn = hsa_ext_null;
+  pcs_api.hsa_ven_amd_pcs_flush_fn = hsa_ext_null;
+}
+
 // Initialize Amd Ext table for Api related to Images
 void ExtensionEntryPoints::InitAmdExtTable() {
   hsa_api_table_.amd_ext_api.hsa_amd_image_create_fn = hsa_ext_null;
@@ -131,6 +149,9 @@ void ExtensionEntryPoints::UnloadImage() {
 void ExtensionEntryPoints::Unload() {
   // Reset Image apis to hsa_ext_null function
   UnloadImage();
+#ifdef HSA_PC_SAMPLING_SUPPORT
+  rocr::pcs::ReleasePcSamplingRsrcs();
+#endif
 
   for (auto lib : libs_) {
     void* ptr = os::GetExportAddress(lib, "Unload");
@@ -148,6 +169,7 @@ void ExtensionEntryPoints::Unload() {
   libs_.clear();
 
   InitFinalizerExtTable();
+  InitPcSamplingExtTable();
   InitImageExtTable();
   InitAmdExtTable();
   core::hsa_internal_api_table_.Reset();
@@ -180,6 +202,23 @@ bool ExtensionEntryPoints::LoadImage() {
   return true;
 }
 
+void ExtensionEntryPoints::LoadPcSampling() {
+#ifdef HSA_PC_SAMPLING_SUPPORT
+  if (core::Runtime::runtime_singleton_->flag().disable_pc_sampling()) return;
+
+  // Bind to Image implementation api's
+  rocr::pcs::LoadPcSampling(&pcs_api);
+
+  // Initialize Version of Api Table
+  pcs_api.version.major_id = HSA_PC_SAMPLING_API_TABLE_MAJOR_VERSION;
+  pcs_api.version.minor_id = sizeof(PcSamplingExtTable);
+  pcs_api.version.step_id = HSA_PC_SAMPLING_API_TABLE_STEP_VERSION;
+
+  // Update private copy of Api table with handle for Image extensions
+  hsa_internal_api_table_.CloneExts(&pcs_api, core::HsaApiTable::HSA_EXT_PC_SAMPLING_API_TABLE_ID);
+#endif
+}
+
 bool ExtensionEntryPoints::LoadFinalizer(std::string library_name) {
   os::LibHandle lib = os::LoadLib(library_name);
   if (lib == NULL) {
@@ -429,6 +468,54 @@ hsa_status_t hsa_ext_image_create_with_layout(
                                image);
 }
 
+hsa_status_t HSA_API hsa_ven_amd_pcs_iterate_configuration(
+    hsa_agent_t agent, hsa_ven_amd_pcs_iterate_configuration_callback_t configuration_callback,
+    void* callback_data) {
+  return rocr::core::Runtime::runtime_singleton_->extensions_.pcs_api
+      .hsa_ven_amd_pcs_iterate_configuration_fn(agent, configuration_callback, callback_data);
+}
+
+hsa_status_t HSA_API hsa_ven_amd_pcs_create(
+    hsa_agent_t agent, hsa_ven_amd_pcs_method_kind_t method, hsa_ven_amd_pcs_units_t units,
+    size_t interval, size_t latency, size_t buffer_size,
+    hsa_ven_amd_pcs_data_ready_callback_t data_ready_callback, void* client_callback_data,
+    hsa_ven_amd_pcs_t* pc_sampling) {
+  return rocr::core::Runtime::runtime_singleton_->extensions_.pcs_api.hsa_ven_amd_pcs_create_fn(
+      agent, method, units, interval, latency, buffer_size, data_ready_callback,
+      client_callback_data, pc_sampling);
+}
+
+hsa_status_t HSA_API hsa_ven_amd_pcs_create_from_id(
+    uint32_t pcs_id, hsa_agent_t agent, hsa_ven_amd_pcs_method_kind_t method,
+    hsa_ven_amd_pcs_units_t units, size_t interval, size_t latency, size_t buffer_size,
+    hsa_ven_amd_pcs_data_ready_callback_t data_ready_callback, void* client_callback_data,
+    hsa_ven_amd_pcs_t* pc_sampling) {
+  return rocr::core::Runtime::runtime_singleton_->extensions_.pcs_api
+      .hsa_ven_amd_pcs_create_from_id_fn(pcs_id, agent, method, units, interval, latency,
+                                         buffer_size, data_ready_callback, client_callback_data,
+                                         pc_sampling);
+}
+
+hsa_status_t HSA_API hsa_ven_amd_pcs_destroy(hsa_ven_amd_pcs_t pc_sampling) {
+  return rocr::core::Runtime::runtime_singleton_->extensions_.pcs_api.hsa_ven_amd_pcs_destroy_fn(
+      pc_sampling);
+}
+
+hsa_status_t HSA_API hsa_ven_amd_pcs_start(hsa_ven_amd_pcs_t pc_sampling) {
+  return rocr::core::Runtime::runtime_singleton_->extensions_.pcs_api.hsa_ven_amd_pcs_start_fn(
+      pc_sampling);
+}
+
+hsa_status_t HSA_API hsa_ven_amd_pcs_stop(hsa_ven_amd_pcs_t pc_sampling) {
+  return rocr::core::Runtime::runtime_singleton_->extensions_.pcs_api.hsa_ven_amd_pcs_stop_fn(
+      pc_sampling);
+}
+
+hsa_status_t HSA_API hsa_ven_amd_pcs_flush(hsa_ven_amd_pcs_t pc_sampling) {
+  return rocr::core::Runtime::runtime_singleton_->extensions_.pcs_api.hsa_ven_amd_pcs_flush_fn(
+      pc_sampling);
+}
+
 //---------------------------------------------------------------------------//
 //  Stubs for internal extension functions
 //---------------------------------------------------------------------------//

runtime/hsa-runtime/core/runtime/runtime.cpp

@@ -1998,6 +1998,11 @@ void Runtime::LoadExtensions() {
   extensions_.LoadImage();
   hsa_api_table_.LinkExts(&extensions_.image_api,
                           core::HsaApiTable::HSA_EXT_IMAGE_API_TABLE_ID);
+
+  // Update Hsa Api Table with handle of PCS extension Apis
+  extensions_.LoadPcSampling();
+  hsa_api_table_.LinkExts(&extensions_.pcs_api,
+                          core::HsaApiTable::HSA_EXT_PC_SAMPLING_API_TABLE_ID);
 }
 
 void Runtime::UnloadExtensions() { extensions_.Unload(); }

runtime/hsa-runtime/core/util/flag.h

@@ -184,6 +184,9 @@ class Flag {
     var = os::GetEnvVar("HSA_DISABLE_IMAGE");
     disable_image_ = (var == "1") ? true : false;
 
+    var = os::GetEnvVar("HSA_DISABLE_PC_SAMPLING");
+    disable_pc_sampling_ = (var == "1") ? true : false;
+
     var = os::GetEnvVar("HSA_LOADER_ENABLE_MMAP_URI");
     loader_enable_mmap_uri_ = (var == "1") ? true : false;
 
@@ -297,6 +300,8 @@ class Flag {
 
   bool disable_image() const { return disable_image_; }
 
+  bool disable_pc_sampling() const { return disable_pc_sampling_; }
+
   bool loader_enable_mmap_uri() const { return loader_enable_mmap_uri_; }
 
   size_t force_sdma_size() const { return force_sdma_size_; }
@@ -353,6 +358,7 @@ class Flag {
   bool no_scratch_reclaim_;
   bool no_scratch_thread_limit_;
   bool disable_image_;
+  bool disable_pc_sampling_;
   bool loader_enable_mmap_uri_;
   bool check_sramecc_validity_;
   bool debug_;