code object tracking and v3 code object support

Change-Id: I081ada13f6364ea4401a97a485dedfa9bf8a45fe


[ROCm/rocprofiler commit: 60043d198b]

projects/rocprofiler/src/core/intercept_queue.h

@@ -148,9 +148,20 @@ class InterceptQueue {
         }
 
         // Prepareing dispatch callback data
-        const amd_kernel_code_t* kernel_code = GetKernelCode(dispatch_packet);
-        const uint64_t kernel_symbol = kernel_code->runtime_loader_kernel_symbol;
-        const char* kernel_name = GetKernelName(kernel_symbol);
+        uint64_t kernel_object = dispatch_packet->kernel_object;
+        const amd_kernel_code_t* kernel_code = GetKernelCode(kernel_object);
+
+        const uint16_t kernel_object_flag = *((uint64_t*)kernel_code + 1);
+        if (kernel_object_flag == 0) {
+          if (!util::HsaRsrcFactory::IsExecutableTracking()) {
+            fprintf(stderr, "Error: V3 code object detected - code objects tracking should be enabled\n");
+            abort();
+          }
+        }
+        const char* kernel_name = (util::HsaRsrcFactory::IsExecutableTracking()) ?
+          util::HsaRsrcFactory::GetKernelName(kernel_object) :
+          GetKernelName(kernel_code->runtime_loader_kernel_symbol);
+
         rocprofiler_callback_data_t data = {obj->agent_info_->dev_id,
                                             obj->agent_info_->dev_index,
                                             obj->queue_,
@@ -159,7 +170,7 @@ class InterceptQueue {
                                             completion_signal,
                                             dispatch_packet,
                                             kernel_name,
-                                            kernel_symbol,
+                                            kernel_object,
                                             kernel_code,
                                             syscall(__NR_gettid),
                                             (tracker_entry) ? tracker_entry->record : NULL};
@@ -243,14 +254,14 @@ class InterceptQueue {
     return static_cast<hsa_packet_type_t>((*header >> HSA_PACKET_HEADER_TYPE) & header_type_mask);
   }
 
-  static const amd_kernel_code_t* GetKernelCode(const hsa_kernel_dispatch_packet_t* dispatch_packet) {
+  static const amd_kernel_code_t* GetKernelCode(uint64_t kernel_object) {
     const amd_kernel_code_t* kernel_code = NULL;
     hsa_status_t status =
         util::HsaRsrcFactory::Instance().LoaderApi()->hsa_ven_amd_loader_query_host_address(
-            reinterpret_cast<const void*>(dispatch_packet->kernel_object),
+            reinterpret_cast<const void*>(kernel_object),
             reinterpret_cast<const void**>(&kernel_code));
     if (HSA_STATUS_SUCCESS != status) {
-      kernel_code = reinterpret_cast<amd_kernel_code_t*>(dispatch_packet->kernel_object);
+      kernel_code = reinterpret_cast<amd_kernel_code_t*>(kernel_object);
     }
     return kernel_code;
   }

projects/rocprofiler/src/core/rocprofiler.cpp

@@ -144,7 +144,8 @@ void * tool_handle = NULL;
 // Return true if intercepting mode is enabled
 enum {
   DISPATCH_INTERCEPT_MODE = 0x1,
-  MEMCOPY_INTERCEPT_MODE = 0x2
+  CODE_OBJ_TRACKING_MODE = 0x2,
+  MEMCOPY_INTERCEPT_MODE = 0x4,
 };
 uint32_t LoadTool() {
   uint32_t intercept_mode = 0;
@@ -188,6 +189,7 @@ uint32_t LoadTool() {
     util::HsaRsrcFactory::SetTimeoutNs(settings.timeout);
     InterceptQueue::TrackerOn(settings.timestamp_on != 0);
     if (settings.intercept_mode != 0) intercept_mode = DISPATCH_INTERCEPT_MODE;
+    if (settings.code_obj_tracking) intercept_mode |= CODE_OBJ_TRACKING_MODE;
     if (settings.memcopy_tracking) intercept_mode |= MEMCOPY_INTERCEPT_MODE;
   }
 
@@ -432,7 +434,13 @@ PUBLIC_API bool OnLoad(HsaApiTable* table, uint64_t runtime_version, uint64_t fa
 
   // Loading a tool lib and setting of intercept mode
   const uint32_t intercept_mode_mask = rocprofiler::LoadTool();
-  if (intercept_mode_mask & rocprofiler::DISPATCH_INTERCEPT_MODE) intercept_mode = true;
+  if (intercept_mode_mask & rocprofiler::DISPATCH_INTERCEPT_MODE) {
+    intercept_mode = true;
+  }
+  if (intercept_mode_mask & rocprofiler::CODE_OBJ_TRACKING_MODE) {
+    if (intercept_mode == false) EXC_RAISING(HSA_STATUS_ERROR, "code objects tracking without intercept mode enabled");
+    rocprofiler::util::HsaRsrcFactory::EnableExecutableTracking(table);
+  }
   if (intercept_mode_mask & rocprofiler::MEMCOPY_INTERCEPT_MODE) {
     hsa_status_t status = hsa_amd_profiling_async_copy_enable(true);
     if (status != HSA_STATUS_SUCCESS) EXC_ABORT(status, "hsa_amd_profiling_async_copy_enable");