kernel objects dumping

Change-Id: I5a16e05b7df438efa903948701b65a9ced99e5f3

initial codeobj event implementation

Change-Id: Ia7fac3c2b9897a004cfe88c4de82ba8c18284196

update - codeobj event implementation

Change-Id: I2b91b6e689875af03f0086f5a0872a97a629fd83

update2 - codeobj event implementation

Change-Id: Icff75f14fd21963e40db95373fa74880957a9e32

fix - codeobj event implementation

Change-Id: I76c33c875cb429fb12a974bb408b217f187b4536

URI buffer fix - codeobj event implementation

Change-Id: I7ce1a758e021455da3fe5b8a6e4ae3ab46e9760e

HSA events exposing

Change-Id: I3664ab4e5111c4ccedaf068dcb19f48055f0ef9b

HSA events data struct normalizing

Change-Id: I365ef0db45e0a9314bd2a1a4d29dd4eb4e91297d


[ROCm/rocprofiler commit: 8850e46071]

projects/rocprofiler/src/CMakeLists.txt

@@ -35,4 +35,4 @@ set ( LIB_SRC
 )
 add_library ( ${TARGET_LIB} SHARED ${LIB_SRC} )
 target_include_directories ( ${TARGET_LIB} PRIVATE ${LIB_DIR} ${ROOT_DIR} ${HSA_RUNTIME_INC_PATH} ${HSA_KMT_LIB_PATH}/.. )
-target_link_libraries( ${TARGET_LIB} PRIVATE ${HSA_RUNTIME_LIB} c stdc++)
+target_link_libraries( ${TARGET_LIB} PRIVATE ${HSA_RUNTIME_LIB} c stdc++ atomic )

projects/rocprofiler/src/core/activity.cpp

@@ -20,6 +20,9 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 *******************************************************************************/
 
+#define ROCP_INTERNAL_BUILD
+#include "activity.h"
+
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -168,4 +171,65 @@ PUBLIC_API bool EnableActivityCallback(uint32_t op, bool enable) {
   }
   return true;
 }
+
+struct evt_cb_entry_t {
+  void* callback;
+  void* arg;
+};
+typedef std::atomic<evt_cb_entry_t> evt_cb_entry_atomic_t;
+evt_cb_entry_atomic_t evt_cb_table[HSA_EVT_ID_NUMBER]{};
+
+hsa_status_t codeobj_evt_callback(
+  rocprofiler_hsa_cb_id_t id,
+  const rocprofiler_hsa_callback_data_t* cb_data,
+  void* arg)
+{
+  evt_cb_entry_t evt = evt_cb_table[id].load(std::memory_order_relaxed);
+  activity_rtapi_callback_t evt_callback = (activity_rtapi_callback_t)evt.callback;
+
+  if (evt_callback != NULL) {
+    evt_callback(ACTIVITY_DOMAIN_HSA_EVT, id, cb_data, evt.arg);
+  }
+
+  return HSA_STATUS_SUCCESS;
+}
+
+PUBLIC_API const char* GetEvtName(uint32_t op) { return strdup("CODEOBJ"); }
+
+PUBLIC_API bool RegisterEvtCallback(uint32_t op, void* callback, void* arg) {
+  evt_cb_table[op].store(evt_cb_entry_t{callback, arg}, std::memory_order_relaxed);
+
+  rocprofiler_hsa_callbacks_t ocb{};
+  switch (op) {
+    case HSA_EVT_ID_ALLOCATE:
+      ocb.allocate = codeobj_evt_callback;
+      break;
+    case HSA_EVT_ID_DEVICE:
+      ocb.device = codeobj_evt_callback;
+      break;
+    case HSA_EVT_ID_MEMCOPY:
+      ocb.memcopy = codeobj_evt_callback;
+      break;
+    case HSA_EVT_ID_SUBMIT:
+      ocb.submit = codeobj_evt_callback;
+      break;
+    case HSA_EVT_ID_KSYMBOL:
+      ocb.ksymbol = codeobj_evt_callback;
+      break;
+    case HSA_EVT_ID_CODEOBJ:
+      ocb.codeobj = codeobj_evt_callback;
+      break;
+    default:
+      fatal("invalid activity opcode");
+  }
+  rocprofiler_set_hsa_callbacks(ocb, NULL);
+
+  return true;
+}
+
+PUBLIC_API bool RemoveEvtCallback(uint32_t op) {
+  rocprofiler_hsa_callbacks_t ocb{};
+  rocprofiler_set_hsa_callbacks(ocb, NULL);
+  return true;
+}
 }  // extern "C"

projects/rocprofiler/src/core/activity.h

@@ -0,0 +1,26 @@
+#ifndef _SRC_CORE_ACTIVITY_H
+#define _SRC_CORE_ACTIVITY_H
+
+#ifdef ROCP_INTERNAL_BUILD
+#include "inc/rocprofiler.h"
+#else
+#include <rocprofiler/rocprofiler.h>
+#endif
+
+#include <stdint.h>
+
+// HSA EVT ID enumeration
+enum hsa_evt_id_t {
+  HSA_EVT_ID_ALLOCATE = ROCPROFILER_HSA_CB_ID_ALLOCATE,
+  HSA_EVT_ID_DEVICE = ROCPROFILER_HSA_CB_ID_DEVICE,
+  HSA_EVT_ID_MEMCOPY = ROCPROFILER_HSA_CB_ID_MEMCOPY,
+  HSA_EVT_ID_SUBMIT = ROCPROFILER_HSA_CB_ID_SUBMIT,
+  HSA_EVT_ID_KSYMBOL = ROCPROFILER_HSA_CB_ID_KSYMBOL,
+  HSA_EVT_ID_CODEOBJ = ROCPROFILER_HSA_CB_ID_CODEOBJ,
+  HSA_EVT_ID_NUMBER
+};
+
+// HSA EVT callback data type
+typedef rocprofiler_hsa_callback_data_t hsa_evt_data_t;
+
+#endif // _SRC_CORE_ACTIVITY_H

projects/rocprofiler/src/core/hsa_interceptor.h

@@ -51,7 +51,8 @@ SOFTWARE.
     (ID == ROCPROFILER_HSA_CB_ID_DEVICE) ? callbacks_.device: \
     (ID == ROCPROFILER_HSA_CB_ID_MEMCOPY) ? callbacks_.memcopy: \
     (ID == ROCPROFILER_HSA_CB_ID_SUBMIT) ? callbacks_.submit: \
-                                            callbacks_.ksymbol; \
+    (ID == ROCPROFILER_HSA_CB_ID_KSYMBOL) ? callbacks_.ksymbol: \
+                                            callbacks_.codeobj; \
   if ((__callback != NULL) && (recursion_ == false))
 
 #define DO_HSA_CALLBACK \
@@ -230,12 +231,12 @@ class HsaInterceptor {
         rocprofiler_hsa_callback_data_t data{};
         data.allocate.ptr = *ptr;
         data.allocate.size = size;
-  
+
         HSA_RT(hsa_amd_memory_pool_get_info(pool, HSA_AMD_MEMORY_POOL_INFO_SEGMENT, &data.allocate.segment));
         HSA_RT(hsa_amd_memory_pool_get_info(pool, HSA_AMD_MEMORY_POOL_INFO_GLOBAL_FLAGS, &data.allocate.global_flag));
-  
+
         DO_HSA_CALLBACK;
-  
+
         IS_HSA_CALLBACK(ROCPROFILER_HSA_CB_ID_DEVICE) {
           // Scan the pool assigned devices
           agent_callback_data_t callback_data{pool, *ptr};
@@ -303,44 +304,116 @@ class HsaInterceptor {
     void* arg)
   {
     const int free_flag = reinterpret_cast<long>(arg);
-    rocprofiler_hsa_callback_data_t data{};
+    hsa_ven_amd_loader_code_object_storage_type_t storage_type =
+      HSA_VEN_AMD_LOADER_CODE_OBJECT_STORAGE_TYPE_NONE;
+    int storage_fd = -1;
+    uint64_t memory_base = 0;
+    uint64_t memory_size = 0;
+    uint64_t load_base = 0;
+    uint64_t load_size = 0;
+    uint64_t load_delta = 0;
+    uint32_t uri_len = 0;
+    char* uri_str = NULL;
+
+    HSA_RT(LoaderApiTable.hsa_ven_amd_loader_loaded_code_object_get_info(
+      loaded_code_object,
+      HSA_VEN_AMD_LOADER_LOADED_CODE_OBJECT_INFO_CODE_OBJECT_STORAGE_TYPE,
+      &storage_type));
+
+    if (storage_type == HSA_VEN_AMD_LOADER_CODE_OBJECT_STORAGE_TYPE_FILE) {
+      HSA_RT(LoaderApiTable.hsa_ven_amd_loader_loaded_code_object_get_info(
+        loaded_code_object,
+        HSA_VEN_AMD_LOADER_LOADED_CODE_OBJECT_INFO_CODE_OBJECT_STORAGE_FILE,
+        &storage_fd));
+      if (storage_fd == -1) {
+        printf("CodeObjectCallback: fd == -1\n"); fflush(stdout);
+	abort();
+      }
+    } else if (storage_type == HSA_VEN_AMD_LOADER_CODE_OBJECT_STORAGE_TYPE_MEMORY) {
+      HSA_RT(LoaderApiTable.hsa_ven_amd_loader_loaded_code_object_get_info(
+        loaded_code_object,
+        HSA_VEN_AMD_LOADER_LOADED_CODE_OBJECT_INFO_CODE_OBJECT_STORAGE_MEMORY_BASE,
+        &memory_base));
+      HSA_RT(LoaderApiTable.hsa_ven_amd_loader_loaded_code_object_get_info(
+        loaded_code_object,
+        HSA_VEN_AMD_LOADER_LOADED_CODE_OBJECT_INFO_CODE_OBJECT_STORAGE_MEMORY_SIZE,
+        &memory_size));
+    }
 
     HSA_RT(LoaderApiTable.hsa_ven_amd_loader_loaded_code_object_get_info(
       loaded_code_object,
       HSA_VEN_AMD_LOADER_LOADED_CODE_OBJECT_INFO_LOAD_BASE,
-      &data.allocate.ptr));
+      &load_base));
+    HSA_RT(LoaderApiTable.hsa_ven_amd_loader_loaded_code_object_get_info(
+      loaded_code_object,
+      HSA_VEN_AMD_LOADER_LOADED_CODE_OBJECT_INFO_LOAD_SIZE,
+      &load_size));
+    HSA_RT(LoaderApiTable.hsa_ven_amd_loader_loaded_code_object_get_info(
+      loaded_code_object,
+      HSA_VEN_AMD_LOADER_LOADED_CODE_OBJECT_INFO_LOAD_DELTA,
+      &load_delta));
 
-    if (free_flag == 0) {
-      HSA_RT(LoaderApiTable.hsa_ven_amd_loader_loaded_code_object_get_info(
-        loaded_code_object,
-        HSA_VEN_AMD_LOADER_LOADED_CODE_OBJECT_INFO_LOAD_SIZE,
-        &data.allocate.size));
-    } else {
-      data.allocate.size = 0;
+    // Getting URI
+    HSA_RT(LoaderApiTable.hsa_ven_amd_loader_loaded_code_object_get_info(
+      loaded_code_object,
+      HSA_VEN_AMD_LOADER_LOADED_CODE_OBJECT_INFO_URI_LENGTH,
+      &uri_len));
+
+    uri_str = (char*)calloc(uri_len + 1, sizeof(char));
+    if (!uri_str) EXC_ABORT(HSA_STATUS_ERROR, "URI allocation");
+
+    HSA_RT(LoaderApiTable.hsa_ven_amd_loader_loaded_code_object_get_info(
+      loaded_code_object,
+      HSA_VEN_AMD_LOADER_LOADED_CODE_OBJECT_INFO_URI,
+      uri_str));
+
+    if (storage_type != HSA_VEN_AMD_LOADER_CODE_OBJECT_STORAGE_TYPE_NONE) {
+      IS_HSA_CALLBACK(ROCPROFILER_HSA_CB_ID_CODEOBJ) {
+        rocprofiler_hsa_callback_data_t data{};
+        data.codeobj.storage_type = storage_type;
+        data.codeobj.storage_file = storage_fd;
+        data.codeobj.memory_base = memory_base;
+        data.codeobj.memory_size = memory_size;
+        data.codeobj.load_base = load_base;
+        data.codeobj.load_size = load_size;
+        data.codeobj.load_delta = load_delta;
+	data.codeobj.uri_length = uri_len;
+	data.codeobj.uri = uri_str;
+        data.codeobj.unload = free_flag;
+
+        DO_HSA_CALLBACK;
+      }
     }
 
-    // Local GPU memory
-    // GLOBAL; FLAGS: COARSE GRAINED
-    data.allocate.segment = HSA_AMD_SEGMENT_GLOBAL;
-    data.allocate.global_flag = HSA_AMD_MEMORY_POOL_GLOBAL_FLAG_COARSE_GRAINED;
-    data.allocate.is_code = 1;
+    {
+      IS_HSA_CALLBACK(ROCPROFILER_HSA_CB_ID_ALLOCATE) {
+        // Local GPU memory
+        // GLOBAL; FLAGS: COARSE GRAINED
+        rocprofiler_hsa_callback_data_t data{};
+        data.allocate.ptr = reinterpret_cast<void*>(load_base);
+        data.allocate.size = (free_flag == 0) ? load_size : 0;
+        data.allocate.segment = HSA_AMD_SEGMENT_GLOBAL;
+        data.allocate.global_flag = HSA_AMD_MEMORY_POOL_GLOBAL_FLAG_COARSE_GRAINED;
+        data.allocate.is_code = 1;
 
-    ISSUE_HSA_CALLBACK(ROCPROFILER_HSA_CB_ID_ALLOCATE);
+        DO_HSA_CALLBACK;
+      }
+    }
 
-    if (free_flag == 0) {
+    if (free_flag != 0) {
       IS_HSA_CALLBACK(ROCPROFILER_HSA_CB_ID_DEVICE) {
         hsa_amd_pointer_info_t pointer_info{};
         uint32_t num_agents = 0;
         hsa_agent_t* agents = NULL;
         pointer_info.size = sizeof(hsa_amd_pointer_info_t);
         HSA_RT(hsa_amd_pointer_info(
-          const_cast<void*>(data.allocate.ptr),
+          reinterpret_cast<void*>(load_base),
           &pointer_info,
           malloc,
           &num_agents,
           &agents));
-  
-        DeviceCallback(num_agents, agents, data.allocate.ptr);
+
+        DeviceCallback(num_agents, agents, reinterpret_cast<void*>(load_base));
       }
     }
 
@@ -372,7 +445,7 @@ class HsaInterceptor {
       data.ksymbol.object = obj;
       data.ksymbol.name = name;
       data.ksymbol.name_length = len;
-      data.ksymbol.destroy = free_flag;
+      data.ksymbol.unload = free_flag;
 
       ISSUE_HSA_CALLBACK(ROCPROFILER_HSA_CB_ID_KSYMBOL);
     }
@@ -388,22 +461,23 @@ class HsaInterceptor {
 
     HSA_RT(hsa_executable_freeze_fn(executable, options));
 
-    IS_HSA_CALLBACK(ROCPROFILER_HSA_CB_ID_ALLOCATE) {
+    IS_HSA_CALLBACK(ROCPROFILER_HSA_CB_ID_KSYMBOL) {
+      HSA_RT(hsa_executable_iterate_symbols(
+        executable,
+        KernelSymbolCallback,
+        reinterpret_cast<void*>(0)));
+    }
+
+    unsigned is_codeobj_cb = 0;
+    { IS_HSA_CALLBACK(ROCPROFILER_HSA_CB_ID_CODEOBJ) is_codeobj_cb |= 1; }
+    { IS_HSA_CALLBACK(ROCPROFILER_HSA_CB_ID_ALLOCATE) is_codeobj_cb |= 1; }
+    if (is_codeobj_cb) {
       LoaderApiTable.hsa_ven_amd_loader_executable_iterate_loaded_code_objects(
         executable,
         CodeObjectCallback,
         reinterpret_cast<void*>(0));
     }
 
-    {
-      IS_HSA_CALLBACK(ROCPROFILER_HSA_CB_ID_KSYMBOL) {
-        HSA_RT(hsa_executable_iterate_symbols(
-          executable,
-          KernelSymbolCallback,
-          reinterpret_cast<void*>(0)));
-      }
-    }
-
     return status;
   }