standalone/sampling mode

Change-Id: I24c358bfebacb5678fb3d31f2f94ae867a1c9ac9

src/core/hsa_queue.h

@@ -32,15 +32,6 @@ namespace rocprofiler {
 
 class HsaQueue : public Queue {
  public:
-  typedef void (HsaQueue::*submit_fptr_t)(const packet_t* packet);
-  enum {
-    LEGACY_SLOT_SIZE_W = HSA_VEN_AMD_AQLPROFILE_LEGACY_PM4_PACKET_SIZE / sizeof(packet_word_t),
-    LEGACY_SLOT_SIZE_P = HSA_VEN_AMD_AQLPROFILE_LEGACY_PM4_PACKET_SIZE / sizeof(packet_t)
-  };
-  struct slot_pm4_t {
-    packet_word_t words[LEGACY_SLOT_SIZE_W];
-  };
-
   HsaQueue(const util::AgentInfo* agent_info, hsa_queue_t* queue) : queue_(queue) {}
 
   void Submit(const packet_t* packet) {

src/core/metrics.h

@@ -195,7 +195,7 @@ class MetricsDict {
   }
 
   static hsa_ven_amd_aqlprofile_id_query_t Translate(const util::AgentInfo* agent_info, const std::string& block_name) {
-    hsa_ven_amd_aqlprofile_profile_t profile;
+    hsa_ven_amd_aqlprofile_profile_t profile{};
     profile.agent = agent_info->dev_id;
     hsa_ven_amd_aqlprofile_id_query_t query = {block_name.c_str(), 0, 0};
     hsa_status_t status =

src/core/rocprofiler.cpp

@@ -56,6 +56,16 @@ THE SOFTWARE.
 // Internal library methods
 //
 namespace rocprofiler {
+hsa_status_t CreateQueuePro(
+    hsa_agent_t agent,
+    uint32_t size,
+    hsa_queue_type32_t type,
+    void (*callback)(hsa_status_t status, hsa_queue_t *source, void *data),
+    void *data,
+    uint32_t private_segment_size,
+    uint32_t group_segment_size,
+    hsa_queue_t **queue);
+
 decltype(hsa_queue_create)* hsa_queue_create_fn;
 decltype(hsa_queue_destroy)* hsa_queue_destroy_fn;
 
@@ -115,6 +125,11 @@ void RestoreHsaApi() {
   table->amd_ext_->hsa_amd_queue_intercept_register_fn = hsa_amd_queue_intercept_register_fn;
 }
 
+void StandaloneIntercept() {
+  ::HsaApiTable* table = kHsaApiTable;
+  table->core_->hsa_queue_create_fn = rocprofiler::CreateQueuePro;
+}
+
 typedef void (*tool_handler_t)();
 typedef void (*tool_handler_prop_t)(rocprofiler_settings_t*);
 void * tool_handle = NULL;
@@ -195,9 +210,7 @@ DESTRUCTOR_API void destructor() {
 const MetricsDict* GetMetrics(const hsa_agent_t& agent) {
   rocprofiler::util::HsaRsrcFactory* hsa_rsrc = &rocprofiler::util::HsaRsrcFactory::Instance();
   const rocprofiler::util::AgentInfo* agent_info = hsa_rsrc->GetAgentInfo(agent);
-  if (agent_info == NULL) {
-    EXC_RAISING(HSA_STATUS_ERROR, "agent is not found");
-  }
+  if (agent_info == NULL) EXC_RAISING(HSA_STATUS_ERROR, "agent is not found");
   const MetricsDict* metrics = MetricsDict::Create(agent_info);
   if (metrics == NULL) EXC_RAISING(HSA_STATUS_ERROR, "MetricsDict create failed");
   return metrics;
@@ -209,6 +222,94 @@ hsa_status_t GetExcStatus(const std::exception& e) {
                                : HSA_STATUS_ERROR;
 }
 
+
+inline size_t CreateEnableCmd(const hsa_agent_t& agent, packet_t* command, const size_t& slot_count) {
+  rocprofiler::util::HsaRsrcFactory* hsa_rsrc = &rocprofiler::util::HsaRsrcFactory::Instance();
+  const rocprofiler::util::AgentInfo* agent_info = hsa_rsrc->GetAgentInfo(agent);
+  const bool is_legacy = (strncmp(agent_info->name, "gfx8", 4) == 0);
+  const size_t packet_count = (is_legacy) ? Profile::LEGACY_SLOT_SIZE_PKT : 1;
+
+  if (packet_count > slot_count) EXC_RAISING(HSA_STATUS_ERROR, "packet_count > slot_count");
+
+  // AQLprofile object
+  hsa_ven_amd_aqlprofile_profile_t profile{};
+  profile.agent = agent_info->dev_id;
+  // Query for cmd buffer size
+  hsa_status_t status = hsa_rsrc->AqlProfileApi()->hsa_ven_amd_aqlprofile_get_info(
+    &profile, HSA_VEN_AMD_AQLPROFILE_INFO_ENABLE_CMD, NULL);
+  if (status != HSA_STATUS_SUCCESS) EXC_RAISING(status, "get_info(ENABLE_CMD).size exc");
+  if (profile.command_buffer.size == 0) EXC_RAISING(status, "get_info(ENABLE_CMD).size == 0");
+  // Allocate cmd buffer
+  const size_t aligment_mask = 0x100 - 1;
+  profile.command_buffer.ptr =
+    hsa_rsrc->AllocateSysMemory(agent_info, profile.command_buffer.size);
+  if ((reinterpret_cast<uintptr_t>(profile.command_buffer.ptr) & aligment_mask) != 0) {
+    EXC_RAISING(status, "profile.command_buffer.ptr bad alignment");
+  }
+
+  // Generating cmd packet
+  if (is_legacy) {
+    packet_t packet{};
+
+    // Query for cmd buffer data
+    status = hsa_rsrc->AqlProfileApi()->hsa_ven_amd_aqlprofile_get_info(
+      &profile, HSA_VEN_AMD_AQLPROFILE_INFO_ENABLE_CMD, &packet);
+    if (status != HSA_STATUS_SUCCESS) EXC_RAISING(status, "get_info(ENABLE_CMD).data exc");
+
+    // Check for legacy GFXIP
+    status = hsa_rsrc->AqlProfileApi()->hsa_ven_amd_aqlprofile_legacy_get_pm4(&packet, command);
+    if (status != HSA_STATUS_SUCCESS) AQL_EXC_RAISING(status, "hsa_ven_amd_aqlprofile_legacy_get_pm4");
+  } else {
+    // Query for cmd buffer data
+    status = hsa_rsrc->AqlProfileApi()->hsa_ven_amd_aqlprofile_get_info(
+      &profile, HSA_VEN_AMD_AQLPROFILE_INFO_ENABLE_CMD, command);
+    if (status != HSA_STATUS_SUCCESS) EXC_RAISING(status, "get_info(ENABLE_CMD).data exc");
+  }
+
+  // Return cmd packet data size
+  return (packet_count * sizeof(packet_t));
+}
+
+hsa_status_t CreateQueuePro(
+    hsa_agent_t agent,
+    uint32_t size,
+    hsa_queue_type32_t type,
+    void (*callback)(hsa_status_t status, hsa_queue_t *source, void *data),
+    void *data,
+    uint32_t private_segment_size,
+    uint32_t group_segment_size,
+    hsa_queue_t **queue)
+{
+  static packet_t enable_cmd_packet[Profile::LEGACY_SLOT_SIZE_PKT];
+  static size_t enable_cmd_size = 0;
+  static std::mutex enable_cmd_mutex;
+
+  // Create HSA queue
+  hsa_status_t status = hsa_queue_create_fn(
+    agent,
+    size,
+    type,
+    callback,
+    data,
+    private_segment_size,
+    group_segment_size,
+    queue);
+  if (status != HSA_STATUS_SUCCESS) return status;
+
+  // Create 'Enable' cmd packet
+  if (enable_cmd_size == 0) {
+    std::lock_guard<std::mutex> lck(enable_cmd_mutex);
+    if (enable_cmd_size == 0) {
+      enable_cmd_size = CreateEnableCmd(agent, enable_cmd_packet, Profile::LEGACY_SLOT_SIZE_PKT);
+    }
+  }
+
+  // Enable counters for the queue
+  rocprofiler::util::HsaRsrcFactory::Instance().Submit(*queue, enable_cmd_packet, enable_cmd_size);
+
+  return HSA_STATUS_SUCCESS;
+}
+
 rocprofiler_properties_t rocprofiler_properties;
 uint32_t SqttProfile::output_buffer_size_ = 0x2000000;  // 32M
 bool SqttProfile::output_buffer_local_ = true;
@@ -261,7 +362,10 @@ PUBLIC_API bool OnLoad(HsaApiTable* table, uint64_t runtime_version, uint64_t fa
   if (intercept_mode) {
     rocprofiler::ProxyQueue::HsaIntercept(table);
     rocprofiler::InterceptQueue::HsaIntercept(table);
+  } else {
+    rocprofiler::StandaloneIntercept();
   }
+
   return true;
 }
 

src/util/hsa_rsrc_factory.cpp

@@ -550,7 +550,7 @@ bool HsaRsrcFactory::PrintGpuAgents(const std::string& header) {
 }
 
 uint64_t HsaRsrcFactory::Submit(hsa_queue_t* queue, const void* packet) {
-  const uint32_t slot_size_b = 0x40;
+  const uint32_t slot_size_b = CMD_SLOT_SIZE_B;
 
   // adevance command queue
   const uint64_t write_idx = hsa_queue_load_write_index_relaxed(queue);
@@ -578,7 +578,7 @@ uint64_t HsaRsrcFactory::Submit(hsa_queue_t* queue, const void* packet) {
 }
 
 uint64_t HsaRsrcFactory::Submit(hsa_queue_t* queue, const void* packet, size_t size_bytes) {
-  const uint32_t slot_size_b = 0x40;
+  const uint32_t slot_size_b = CMD_SLOT_SIZE_B;
   if ((size_bytes & (slot_size_b - 1)) != 0) {
     fprintf(stderr, "HsaRsrcFactory::Submit: Bad packet size %zx\n", size_bytes);
     abort();

src/util/hsa_rsrc_factory.h

@@ -154,6 +154,7 @@ class HsaTimer {
 
 class HsaRsrcFactory {
  public:
+  static const size_t CMD_SLOT_SIZE_B = 0x40;
   typedef std::recursive_mutex mutex_t;
   typedef HsaTimer::timestamp_t timestamp_t;