Adding rocprofilerv2

Change-Id: Ic0cc280ba207d2b8f6ccae1cd4ac3184152fc1ad


[ROCm/rocprofiler commit: 8032adb64f]

projects/rocprofiler/samples/.clangd

@@ -0,0 +1,10 @@
+---
+If:
+  PathMatch: common/common.h
+
+CompileFlags:
+  Add: ['-x', 'hip']
+
+# Local Variables:
+# mode: yaml
+# End:

projects/rocprofiler/samples/CMakeLists.txt

@@ -0,0 +1,142 @@
+include (CheckCSourceCompiles)
+
+# ############################################################################################################################################
+# ############################################################################################################################################
+# General Requirements
+# ############################################################################################################################################
+# ############################################################################################################################################
+get_property(HSA_RUNTIME_INCLUDE_DIRECTORIES TARGET hsa-runtime64::hsa-runtime64 PROPERTY INTERFACE_INCLUDE_DIRECTORIES)
+find_file(HSA_H hsa.h
+  PATHS ${HSA_RUNTIME_INCLUDE_DIRECTORIES}
+  PATH_SUFFIXES hsa
+  NO_DEFAULT_PATH
+  REQUIRED)
+get_filename_component(HSA_RUNTIME_INC_PATH ${HSA_H} DIRECTORY)
+include_directories(${HSA_RUNTIME_INC_PATH})
+
+# Set the HIP language runtime link flags as FindHIP does not set them.
+set(CMAKE_EXECUTABLE_RUNTIME_HIP_FLAG ${CMAKE_SHARED_LIBRARY_RUNTIME_CXX_FLAG})
+set(CMAKE_EXECUTABLE_RUNTIME_HIP_FLAG_SEP ${CMAKE_SHARED_LIBRARY_RUNTIME_CXX_FLAG_SEP})
+set(CMAKE_EXECUTABLE_RPATH_LINK_HIP_FLAG ${CMAKE_SHARED_LIBRARY_RPATH_LINK_CXX_FLAG})
+
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${ROCM_PATH}/lib/cmake/hip")
+set(CMAKE_HIP_ARCHITECTURES OFF)
+find_package(HIP REQUIRED MODULE)
+
+find_package(Clang REQUIRED CONFIG
+             PATHS "${ROCM_PATH}"
+             PATH_SUFFIXES "llvm/lib/cmake/clang")
+
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/modules" "${ROCM_PATH}/lib/cmake/hip")
+find_package(LibElf REQUIRED)
+find_package(LibDw REQUIRED)
+
+## Add a custom targets to build and run all the tests
+add_custom_target(samples)
+add_dependencies(samples ${ROCPROFILER_TARGET})
+add_custom_target(run-samples COMMAND ${PROJECT_BINARY_DIR}/samples/run_samples.sh DEPENDS samples)
+
+file(GLOB ROCPROFILER_UTIL_SRC_FILES ${PROJECT_SOURCE_DIR}/src/utils/helper.cpp)
+# ############################################################################################################################################
+
+# ############################################################################################################################################
+# ############################################################################################################################################
+# Samples Build & Run Script
+# ############################################################################################################################################
+# ############################################################################################################################################
+
+# ############################################################################################################################################
+# Profiler Samples
+# ############################################################################################################################################
+
+## Build Application Replay Sample
+set_source_files_properties(profiler/application_replay_sample.cpp PROPERTIES HIP_SOURCE_PROPERTY_FORMAT 1)
+hip_add_executable(profiler_application_replay profiler/application_replay_sample.cpp ${ROCPROFILER_UTIL_SRC_FILES})
+target_include_directories(profiler_application_replay PRIVATE ${PROJECT_SOURCE_DIR} ${PROJECT_SOURCE_DIR}/inc ${CMAKE_CURRENT_SOURCE_DIR}/common)
+target_link_libraries(profiler_application_replay PRIVATE ${ROCPROFILER_TARGET} systemd amd_comgr)
+add_dependencies(samples profiler_application_replay)
+install(TARGETS profiler_application_replay RUNTIME DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/samples COMPONENT samples)
+
+## Build Kernel Replay Sample
+set_source_files_properties(profiler/kernel_replay_sample.cpp PROPERTIES HIP_SOURCE_PROPERTY_FORMAT 1)
+hip_add_executable(profiler_kernel_replay profiler/kernel_replay_sample.cpp ${ROCPROFILER_UTIL_SRC_FILES})
+target_include_directories(profiler_kernel_replay PRIVATE ${PROJECT_SOURCE_DIR} ${PROJECT_SOURCE_DIR}/inc ${CMAKE_CURRENT_SOURCE_DIR}/common)
+target_link_libraries(profiler_kernel_replay PRIVATE ${ROCPROFILER_TARGET} systemd amd_comgr)
+add_dependencies(samples profiler_kernel_replay)
+install(TARGETS profiler_kernel_replay RUNTIME DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/samples COMPONENT samples)
+
+## Build User Replay Sample
+set_source_files_properties(profiler/user_replay_sample.cpp PROPERTIES HIP_SOURCE_PROPERTY_FORMAT 1)
+hip_add_executable(profiler_user_replay profiler/user_replay_sample.cpp ${ROCPROFILER_UTIL_SRC_FILES})
+target_include_directories(profiler_user_replay PRIVATE ${PROJECT_SOURCE_DIR} ${PROJECT_SOURCE_DIR}/inc ${CMAKE_CURRENT_SOURCE_DIR}/common)
+target_link_libraries(profiler_user_replay PRIVATE ${ROCPROFILER_TARGET} systemd amd_comgr)
+add_dependencies(samples profiler_user_replay)
+install(TARGETS profiler_user_replay RUNTIME DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/samples COMPONENT samples)
+
+## Build Device Profiling Sample
+set_source_files_properties(profiler/device_profiling_sample.cpp PROPERTIES HIP_SOURCE_PROPERTY_FORMAT 1)
+hip_add_executable(profiler_device_profiling profiler/device_profiling_sample.cpp ${ROCPROFILER_UTIL_SRC_FILES})
+target_include_directories(profiler_device_profiling PRIVATE ${PROJECT_SOURCE_DIR} ${PROJECT_SOURCE_DIR}/inc ${CMAKE_CURRENT_SOURCE_DIR}/common)
+target_link_libraries(profiler_device_profiling PRIVATE ${ROCPROFILER_TARGET} systemd amd_comgr)
+add_dependencies(samples profiler_device_profiling)
+install(TARGETS profiler_device_profiling RUNTIME DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/samples COMPONENT samples)
+
+# ############################################################################################################################################
+# Tracer Samples
+# ############################################################################################################################################
+
+## Build HIP/HSA Trace Sample
+set_source_files_properties(tracer/sample.cpp PROPERTIES HIP_SOURCE_PROPERTY_FORMAT 1)
+hip_add_executable(tracer_hip_hsa tracer/sample.cpp ${ROCPROFILER_UTIL_SRC_FILES})
+target_include_directories(tracer_hip_hsa PRIVATE ${PROJECT_SOURCE_DIR} ${PROJECT_SOURCE_DIR}/inc ${CMAKE_CURRENT_SOURCE_DIR}/common)
+target_link_libraries(tracer_hip_hsa PRIVATE ${ROCPROFILER_TARGET} systemd amd_comgr)
+add_dependencies(samples tracer_hip_hsa)
+install(TARGETS tracer_hip_hsa RUNTIME DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/samples COMPONENT samples)
+
+# ############################################################################################################################################
+# PC Sampling Samples
+# ############################################################################################################################################
+
+set(CODE_PRINTING_SAMPLE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/pcsampler/code_printing_sample)
+file(GLOB PC_SAMPLING_CODE_PRINTING_FILES ${CODE_PRINTING_SAMPLE_DIR}/*.cpp)
+set_source_files_properties(${PC_SAMPLING_CODE_PRINTING_FILES} PROPERTIES HIP_SOURCE_PROPERTY_FORMAT 1)
+hip_add_executable(pc_sampling_code_printing ${PC_SAMPLING_CODE_PRINTING_FILES}
+  HIPCC_OPTIONS
+  -std=c++17
+  # Include debugging symbols and source for the contextual disassembly
+  -gdwarf-4)
+
+check_c_source_compiles("
+  #define _GNU_SOURCE
+  #include <sys/mman.h>
+  int main() { return memfd_create (\"cmake_test\", 0); }
+  " HAVE_MEMFD_CREATE)
+if (HAVE_MEMFD_CREATE)
+  target_compile_definitions(pc_sampling_code_printing PRIVATE HAVE_MEMFD_CREATE)
+endif()
+
+target_link_libraries(pc_sampling_code_printing
+  PRIVATE
+  ${ROCPROFILER_TARGET}
+  rocm-dbgapi
+  ${LIBELF_LIBRARIES}
+  ${LIBDW_LIBRARIES}
+  hsa-runtime64::hsa-runtime64 Threads::Threads dl)
+target_include_directories(pc_sampling_code_printing
+  PRIVATE
+  # INTERFACE_INCLUDE_DIRECTORIES
+  ${TEST_DIR}
+  ${ROOT_DIR}
+  ${HSA_RUNTIME_INC_PATH}
+  ${PROJECT_SOURCE_DIR})
+add_dependencies(samples pc_sampling_code_printing)
+install(TARGETS pc_sampling_code_printing RUNTIME DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/samples COMPONENT samples)
+
+# ############################################################################################################################################
+# Scripts to run samples
+# ############################################################################################################################################
+
+# Copy run_samples script to samples folder
+configure_file(run_samples.sh ${PROJECT_BINARY_DIR}/samples COPYONLY)
+
+# ############################################################################################################################################

projects/rocprofiler/samples/common/common.h

@@ -0,0 +1,350 @@
+#include <hip/hip_runtime.h>
+#include <rocprofiler.h>
+
+#include <cxxabi.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <systemd/sd-id128.h>
+
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <vector>
+#include <cassert>
+#include <cstddef>
+#include <fstream>
+#include <iostream>
+#include <memory>
+#include <optional>
+#include <ostream>
+#include <sstream>
+#include <string>
+#include <mutex>
+
+#include "src/utils/helper.h"
+
+// Custom assert to print error messages
+#define ASSERTM(exp, msg) assert(((void)msg, exp))
+
+// Macro to check HIP calls status
+#define HIP_CALL(call)                                                                             \
+  do {                                                                                             \
+    hipError_t err = call;                                                                         \
+    if (err != hipSuccess) {                                                                       \
+      fprintf(stderr, "%s\n", hipGetErrorString(err));                                             \
+      abort();                                                                                     \
+    }                                                                                              \
+  } while (0)
+
+// Macro to check ROCPROFILER calls status
+#define CHECK_ROCPROFILER(call)                                                                      \
+  do {                                                                                             \
+    if ((call) != ROCPROFILER_STATUS_SUCCESS) rocmtools::fatal("Error: ROCMTools API Call Error!");  \
+  } while (false)
+
+// Device (Kernel) functions, it must be void
+__global__ void kernelA() { printf("\nKernel A\n"); }
+__global__ void kernelB() { printf("\nKernel B\n"); }
+__global__ void kernelC() { printf("\nKernel C\n"); }
+__global__ void kernelD() { printf("\nKernel D\n"); }
+__global__ void kernelE() { printf("\nKernel E\n"); }
+__global__ void kernelF() { printf("\nKernel F\n"); }
+
+[[maybe_unused]] uint32_t GetPid() {
+  static uint32_t pid = syscall(__NR_getpid);
+  return pid;
+}
+
+[[maybe_unused]] uint64_t GetMachineID() {
+  char hostname[1023] = "\0";
+  gethostname(hostname, 1023);
+  sd_id128_t ret;
+  char machine_id[SD_ID128_STRING_MAX];
+  [[maybe_unused]] int status = sd_id128_get_machine(&ret);
+  assert(status == 0 && "Error: Couldn't get machine id!");
+  if (sd_id128_to_string(ret, machine_id)) return std::hash<std::string>{}(machine_id);
+  return std::rand();
+}
+
+std::ofstream output_file;
+
+void prepare() {
+  output_file.copyfmt(std::cout);
+  output_file.clear(std::cout.rdstate());
+  output_file.basic_ios<char>::rdbuf(std::cout.rdbuf());
+}
+
+std::mutex writing_lock;
+
+const char* GetDomainName(rocprofiler_tracer_activity_domain_t domain) {
+  switch (domain) {
+    case ACTIVITY_DOMAIN_ROCTX:
+      return "ROCTX_DOMAIN";
+      break;
+    case ACTIVITY_DOMAIN_HIP_API:
+      return "HIP_API_DOMAIN";
+      break;
+    case ACTIVITY_DOMAIN_HIP_OPS:
+      return "HIP_OPS_DOMAIN";
+      break;
+    case ACTIVITY_DOMAIN_HSA_API:
+      return "HSA_API_DOMAIN";
+      break;
+    case ACTIVITY_DOMAIN_HSA_OPS:
+      return "HSA_OPS_DOMAIN";
+      break;
+    case ACTIVITY_DOMAIN_HSA_EVT:
+      return "HSA_EVT_DOMAIN";
+      break;
+    default:
+      return "";
+  }
+}
+
+// Flush function needs to be provided by the user to be used in three cases by
+// the user buffer:
+//   1- Application is finished
+//   2- Buffer is full
+//   3- Flush Interval specified by the user
+void FlushTracerRecord(rocprofiler_record_tracer_t tracer_record, rocprofiler_session_id_t session_id,
+                       rocprofiler_buffer_id_t buffer_id = rocprofiler_buffer_id_t{0}) {
+  std::lock_guard<std::mutex> lock(writing_lock);
+  std::string kernel_name;
+  std::string function_name;
+  std::string roctx_message;
+  uint64_t roctx_id;
+  if ((tracer_record.operation_id.id == 0 && tracer_record.domain == ACTIVITY_DOMAIN_HIP_OPS)) {
+    if (tracer_record.api_data_handle.handle &&
+        strlen(reinterpret_cast<const char*>(tracer_record.api_data_handle.handle)) > 1)
+      kernel_name = rocmtools::cxx_demangle(
+          reinterpret_cast<const char*>(tracer_record.api_data_handle.handle));
+  }
+  if (tracer_record.domain == ACTIVITY_DOMAIN_HSA_API) {
+    size_t function_name_size = 0;
+    CHECK_ROCPROFILER(rocprofiler_query_hsa_tracer_api_data_info_size(
+        session_id, ROCPROFILER_HSA_FUNCTION_NAME, tracer_record.api_data_handle,
+        tracer_record.operation_id, &function_name_size));
+    if (function_name_size > 1) {
+      char* function_name_c = (char*)malloc(function_name_size);
+      CHECK_ROCPROFILER(rocprofiler_query_hsa_tracer_api_data_info(
+          session_id, ROCPROFILER_HSA_FUNCTION_NAME, tracer_record.api_data_handle,
+          tracer_record.operation_id, &function_name_c));
+      if (function_name_c) function_name = std::string(function_name_c);
+    }
+  }
+  if (tracer_record.domain == ACTIVITY_DOMAIN_HIP_API) {
+    size_t function_name_size = 0;
+    CHECK_ROCPROFILER(rocprofiler_query_hip_tracer_api_data_info_size(
+        session_id, ROCPROFILER_HIP_FUNCTION_NAME, tracer_record.api_data_handle,
+        tracer_record.operation_id, &function_name_size));
+    if (function_name_size > 1) {
+      char* function_name_c = (char*)malloc(function_name_size);
+      CHECK_ROCPROFILER(rocprofiler_query_hip_tracer_api_data_info(
+          session_id, ROCPROFILER_HIP_FUNCTION_NAME, tracer_record.api_data_handle,
+          tracer_record.operation_id, &function_name_c));
+      if (function_name_c) function_name = std::string(function_name_c);
+    }
+    size_t kernel_name_size = 0;
+    CHECK_ROCPROFILER(rocprofiler_query_hip_tracer_api_data_info_size(
+        session_id, ROCPROFILER_HIP_KERNEL_NAME, tracer_record.api_data_handle,
+        tracer_record.operation_id, &kernel_name_size));
+    if (kernel_name_size > 1) {
+      char* kernel_name_str = (char*)malloc(kernel_name_size * sizeof(char));
+      CHECK_ROCPROFILER(rocprofiler_query_hip_tracer_api_data_info(
+          session_id, ROCPROFILER_HIP_KERNEL_NAME, tracer_record.api_data_handle,
+          tracer_record.operation_id, &kernel_name_str));
+      if (kernel_name_str) kernel_name = rocmtools::cxx_demangle(std::string(kernel_name_str));
+    }
+  }
+  if (tracer_record.domain == ACTIVITY_DOMAIN_ROCTX) {
+    size_t roctx_message_size = 0;
+    CHECK_ROCPROFILER(rocprofiler_query_roctx_tracer_api_data_info_size(
+        session_id, ROCPROFILER_ROCTX_MESSAGE, tracer_record.api_data_handle,
+        tracer_record.operation_id, &roctx_message_size));
+    if (roctx_message_size > 1) {
+      [[maybe_unused]] char* roctx_message_str =
+          static_cast<char*>(malloc(roctx_message_size * sizeof(char)));
+      CHECK_ROCPROFILER(rocprofiler_query_roctx_tracer_api_data_info(
+          session_id, ROCPROFILER_ROCTX_MESSAGE, tracer_record.api_data_handle,
+          tracer_record.operation_id, &roctx_message_str));
+      if (roctx_message_str)
+        roctx_message = rocmtools::cxx_demangle(std::string(strdup(roctx_message_str)));
+    }
+    size_t roctx_id_size = 0;
+    CHECK_ROCPROFILER(rocprofiler_query_roctx_tracer_api_data_info_size(
+        session_id, ROCPROFILER_ROCTX_ID, tracer_record.api_data_handle, tracer_record.operation_id,
+        &roctx_id_size));
+    if (roctx_id_size > 1) {
+      [[maybe_unused]] char* roctx_id_str =
+          static_cast<char*>(malloc(roctx_id_size * sizeof(char)));
+      CHECK_ROCPROFILER(rocprofiler_query_roctx_tracer_api_data_info(
+          session_id, ROCPROFILER_ROCTX_ID, tracer_record.api_data_handle, tracer_record.operation_id,
+          &roctx_id_str));
+      if (roctx_id_str) {
+        roctx_id = std::stoll(std::string(strdup(roctx_id_str)));
+        free(roctx_id_str);
+      }
+    }
+  }
+  output_file << "Record [" << tracer_record.header.id.handle << "], Domain("
+              << GetDomainName(tracer_record.domain) << "), Begin("
+              << tracer_record.timestamps.begin.value << "), End("
+              << tracer_record.timestamps.end.value << "), Correlation ID( "
+              << tracer_record.correlation_id.value << ")";
+  if (roctx_id >= 0) output_file << ", ROCTX ID(" << roctx_id << ")";
+  if (roctx_message.size() > 1) output_file << ", ROCTX Message(" << roctx_message << ")";
+  if (function_name.size() > 1) output_file << ", Function(" << function_name << ")";
+  if (kernel_name.size() > 1) output_file << ", Kernel Name(" << kernel_name.c_str() << ")";
+  output_file << std::endl;
+}
+
+void FlushProfilerRecord(const rocprofiler_record_profiler_t* profiler_record,
+                         rocprofiler_session_id_t session_id, rocprofiler_buffer_id_t buffer_id) {
+  std::lock_guard<std::mutex> lock(writing_lock);
+  size_t name_length = 0;
+  bool is_counter = true;
+  CHECK_ROCPROFILER(rocprofiler_query_kernel_info_size(ROCPROFILER_KERNEL_NAME,
+                                                   profiler_record->kernel_id, &name_length));
+  // Taken from rocprofiler: The size hasn't changed in  recent past
+  static const uint32_t lds_block_size = 128 * 4;
+  const char* kernel_name_c;
+  if (name_length > 1) {
+    kernel_name_c = static_cast<const char*>(malloc(name_length * sizeof(char)));
+    CHECK_ROCPROFILER(rocprofiler_query_kernel_info(ROCPROFILER_KERNEL_NAME, profiler_record->kernel_id,
+                                                &kernel_name_c));
+  }
+  output_file << std::string("dispatch[") << std::to_string(profiler_record->header.id.handle)
+              << "], " << std::string("gpu_id(") << std::to_string(profiler_record->gpu_id.handle)
+              << "), " << std::string("queue_id(")
+              << std::to_string(profiler_record->queue_id.handle) << "), "
+              << std::string("queue_index(") << std::to_string(profiler_record->queue_idx.value)
+              << "), " << std::string("pid(") << std::to_string(GetPid()) << "), "
+              << std::string("tid(") << std::to_string(profiler_record->thread_id.value) << ")";
+  output_file << ", " << std::string("grd(")
+              << std::to_string(profiler_record->kernel_properties.grid_size) << "), "
+              << std::string("wgr(")
+              << std::to_string(profiler_record->kernel_properties.workgroup_size) << "), "
+              << std::string("lds(")
+              << std::to_string(
+                     ((profiler_record->kernel_properties.lds_size + (lds_block_size - 1)) &
+                      ~(lds_block_size - 1)))
+              << "), " << std::string("scr(")
+              << std::to_string(profiler_record->kernel_properties.scratch_size) << "), "
+              << std::string("arch_vgpr(")
+              << std::to_string(profiler_record->kernel_properties.arch_vgpr_count) << "), "
+              << std::string("accum_vgpr(")
+              << std::to_string(profiler_record->kernel_properties.accum_vgpr_count) << "), "
+              << std::string("sgpr(")
+              << std::to_string(profiler_record->kernel_properties.sgpr_count) << "), "
+              << std::string("wave_size(")
+              << std::to_string(profiler_record->kernel_properties.wave_size) << "), "
+              << std::string("sig(")
+              << std::to_string(profiler_record->kernel_properties.signal_handle);
+  std::string kernel_name = rocmtools::cxx_demangle(kernel_name_c);
+  output_file << "), " << std::string("obj(") << std::to_string(profiler_record->kernel_id.handle)
+              << "), " << std::string("kernel-name(\"") << kernel_name << "\")"
+              << std::string(", time(") << std::to_string(profiler_record->timestamps.begin.value)
+              << ") ";
+
+  // For Counters
+  output_file << std::endl;
+  if (profiler_record->counters) {
+    for (uint64_t i = 0; i < profiler_record->counters_count.value; i++) {
+      if (profiler_record->counters[i].counter_handler.handle > 0) {
+        size_t counter_name_length = 0;
+        CHECK_ROCPROFILER(rocprofiler_query_counter_info_size(
+            session_id, ROCPROFILER_COUNTER_NAME, profiler_record->counters[i].counter_handler,
+            &counter_name_length));
+        if (counter_name_length > 1) {
+          const char* name_c = static_cast<const char*>(malloc(name_length * sizeof(char)));
+          CHECK_ROCPROFILER(rocprofiler_query_counter_info(session_id, ROCPROFILER_COUNTER_NAME,
+                                                       profiler_record->counters[i].counter_handler,
+                                                       &name_c));
+          output_file << ", " << name_c << " ("
+                      << std::to_string(profiler_record->counters[i].value.value) << ")"
+                      << std::endl;
+        }
+      }
+    }
+  }
+}
+
+void FlushPCSamplingRecord(
+  const rocprofiler_record_pc_sample_t *pc_sampling_record) {
+  const auto &sample = pc_sampling_record->pc_sample;
+  output_file << "dispatch[" << sample.dispatch_id.value << "], "
+              << "timestamp(" << sample.timestamp.value << "), "
+              << "gpu_id(" << sample.gpu_id.handle << "), "
+              << "pc-sample(" << std::hex << std::showbase << sample.pc << "), "
+              << "se(" << sample.se << ')'
+              << std::endl;
+}
+
+int WriteBufferRecords(const rocprofiler_record_header_t* begin, const rocprofiler_record_header_t* end,
+                       rocprofiler_session_id_t session_id, rocprofiler_buffer_id_t buffer_id) {
+  while (begin < end) {
+    if (!begin) return 0;
+    switch (begin->kind) {
+      case ROCPROFILER_PROFILER_RECORD: {
+        const rocprofiler_record_profiler_t* profiler_record =
+            reinterpret_cast<const rocprofiler_record_profiler_t*>(begin);
+        FlushProfilerRecord(profiler_record, session_id, buffer_id);
+        break;
+      }
+      case ROCPROFILER_TRACER_RECORD: {
+        rocprofiler_record_tracer_t* tracer_record = const_cast<rocprofiler_record_tracer_t*>(
+            reinterpret_cast<const rocprofiler_record_tracer_t*>(begin));
+        FlushTracerRecord(*tracer_record, session_id, buffer_id);
+        break;
+      }
+      case ROCPROFILER_PC_SAMPLING_RECORD: {
+        const rocprofiler_record_pc_sample_t *pc_sampling_record =
+         reinterpret_cast<const rocprofiler_record_pc_sample_t *>(begin);
+        FlushPCSamplingRecord(pc_sampling_record);
+        break;
+      }
+      default: {
+        break;
+      }
+    }
+    rocprofiler_next_record(begin, &begin, session_id, buffer_id);
+  }
+  return 0;
+}
+
+void kernelCalls(char c) {
+  switch (c) {
+    case 'A': {
+      hipLaunchKernelGGL(kernelA, dim3(1), dim3(1), 0, 0);
+      break;
+    }
+    case 'B': {
+      hipLaunchKernelGGL(kernelB, dim3(1), dim3(1), 0, 0);
+      break;
+    }
+    case 'C': {
+      hipLaunchKernelGGL(kernelC, dim3(1), dim3(1), 0, 0);
+      break;
+    }
+    case 'D': {
+      hipLaunchKernelGGL(kernelD, dim3(1), dim3(1), 0, 0);
+      break;
+    }
+    case 'E': {
+      hipLaunchKernelGGL(kernelE, dim3(1), dim3(1), 0, 0);
+      break;
+    }
+    case 'F': {
+      hipLaunchKernelGGL(kernelF, dim3(1), dim3(1), 0, 0);
+      break;
+    }
+    default: {
+      fprintf(stderr, "Error: Wrong Kernel character (%c) Given for kernelCalls!\n", c);
+    }
+  }
+}

projects/rocprofiler/samples/input.txt

@@ -0,0 +1 @@
+pmc: SQ_WAVES GRBM_COUNT GRBM_GUI_ACTIVE SQ_INSTS_VALU FETCH_SIZE

projects/rocprofiler/samples/pcsampler/code_printing_sample/.clangd

@@ -0,0 +1,10 @@
+---
+If:
+  PathMatch: main.cpp
+
+CompileFlags:
+  Add: ['-x', 'hip']
+
+# Local Variables:
+# mode: yaml
+# End:

projects/rocprofiler/samples/pcsampler/code_printing_sample/code_printing.hpp

@@ -0,0 +1,126 @@
+/* Copyright (c) 2022 Advanced Micro Devices, Inc.
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE. */
+
+#ifndef SAMPLES_PCSAMPLER_CODE_PRINTING_SAMPLE_CODE_PRINTING_HPP_
+#define SAMPLES_PCSAMPLER_CODE_PRINTING_SAMPLE_CODE_PRINTING_HPP_
+
+#include <map>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include <amd-dbgapi/amd-dbgapi.h>
+
+namespace amd::debug_agent {
+
+class code_object_t {
+    struct symbol_info_t {
+        const std::string m_name;
+        amd_dbgapi_global_address_t m_value;
+        amd_dbgapi_size_t m_size;
+    };
+
+    using symbol_map_t =
+      std::optional
+        < std::map
+          < amd_dbgapi_global_address_t
+          , std::pair<std::string, amd_dbgapi_size_t>
+          >
+        >;
+
+public:
+    void load_symbol_map();
+    void load_debug_info();
+
+    std::optional<symbol_info_t>
+    find_symbol(amd_dbgapi_global_address_t address);
+
+    code_object_t(amd_dbgapi_code_object_id_t code_object_id);
+    code_object_t(code_object_t &&rhs);
+
+    ~code_object_t();
+
+    void open();
+    bool is_open() const { return m_fd.has_value(); }
+
+    amd_dbgapi_global_address_t load_address() const { return m_load_address; }
+    amd_dbgapi_size_t mem_size() const { return m_mem_size; }
+    // FIXME(?): extra function not in rocr-debug-agent
+    uint32_t elf_amdgpu_machine() const { return m_elf_amdgpu_machine; }
+
+    void disassemble_around(amd_dbgapi_architecture_id_t architecture_id,
+                            amd_dbgapi_global_address_t pc);
+
+    void disassemble_kernel(amd_dbgapi_architecture_id_t architecture_id,
+                            amd_dbgapi_global_address_t start_addr,
+                            bool const print_src = false);
+
+    bool save(const std::string &directory) const;
+
+    amd_dbgapi_global_address_t m_load_address{ 0 };
+    amd_dbgapi_size_t m_mem_size{ 0 };
+    std::optional<int> m_fd;
+
+    std::optional
+      < std::map<amd_dbgapi_global_address_t, std::pair<std::string, size_t>>
+      >
+    m_line_number_map;
+
+    std::optional
+      < std::map<amd_dbgapi_global_address_t, amd_dbgapi_global_address_t>
+      >
+    m_pc_ranges_map;
+
+    symbol_map_t m_symbol_map;
+    std::string m_uri;
+    amd_dbgapi_code_object_id_t const m_code_object_id;
+    // FIXME(?): extra field not in rocr-debug-agent
+    uint32_t m_elf_amdgpu_machine{ 0 };
+};
+
+} // namespace amd::debug_agent
+
+enum struct disassembly_mode {
+    AROUND,
+    KERNEL
+};
+
+std::tuple
+  < amd_dbgapi_process_id_t
+  , std::map<amd_dbgapi_global_address_t, amd::debug_agent::code_object_t>
+  >
+init_disassembly();
+
+void
+disassemble(
+  disassembly_mode const mode,
+  amd_dbgapi_process_id_t const process_id,
+  std::map<amd_dbgapi_global_address_t, amd::debug_agent::code_object_t>
+    &code_object_map,
+  uint64_t const addr);
+
+void
+print_pc_context(
+  amd_dbgapi_process_id_t const process_id,
+  std::map<amd_dbgapi_global_address_t, amd::debug_agent::code_object_t>
+    &code_object_map,
+  amd_dbgapi_global_address_t const pc);
+
+#endif // SAMPLES_PCSAMPLER_CODE_PRINTING_SAMPLE_CODE_PRINTING_HPP_

projects/rocprofiler/samples/pcsampler/code_printing_sample/disassembly.cpp

@@ -0,0 +1,215 @@
+/* Copyright (c) 2022 Advanced Micro Devices, Inc.
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE. */
+
+#include <algorithm>
+#include <atomic>
+#include <functional>
+#include <map>
+#include <mutex>
+#include <optional>
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <unordered_map>
+#include <vector>
+#include <cassert>
+#include <cinttypes>
+#include <cstdint>
+#include <cstdio>
+
+#include <sys/mman.h>
+
+#include <hsa/hsa.h>
+#include <amd-dbgapi/amd-dbgapi.h>
+#include <hsa/amd_hsa_kernel_code.h>
+#include <hsa/hsa_ven_amd_loader.h>
+
+#include "inc/rocprofiler.h"
+
+#include "code_printing.hpp"
+#include "program.hpp"
+
+struct libc_freer {
+    void operator()(char *p) { free(p); }
+};
+
+namespace util {
+
+template <typename T, typename... Ts>
+static void
+hash_combine(size_t &hsh, T const& v, Ts const&... rest)
+{
+    hsh ^= std::hash<T>{}(v) + 0x9e3779b9 + (hsh << 6) + (hsh >> 2);
+    (hash_combine(hsh, rest), ...);
+}
+
+} // namespace util
+
+[[maybe_unused]]
+static inline bool
+operator==(hsa_executable_t const &l, hsa_executable_t const &r)
+{
+    return l.handle == r.handle;
+}
+
+[[maybe_unused]]
+static inline bool
+operator==(
+  rocprofiler_kernel_dispatch_id_t const &l,
+  rocprofiler_kernel_dispatch_id_t const &r)
+{
+    return l.value == r.value;
+}
+
+static inline bool
+operator==(amd_dbgapi_process_id_t const &l, amd_dbgapi_process_id_t const &r)
+{
+    return l.handle == r.handle;
+}
+
+static inline bool
+operator!=(amd_dbgapi_process_id_t const &l, amd_dbgapi_process_id_t const &r)
+{
+    return !(l == r);
+}
+
+namespace std {
+
+template <>
+struct hash<hsa_executable_t> {
+    size_t operator()(hsa_executable_t const &v) const {
+        size_t ret = 0;
+        util::hash_combine(ret, v.handle);
+        return ret;
+    }
+};
+
+template <>
+struct hash<rocprofiler_kernel_dispatch_id_t> {
+    size_t operator()(rocprofiler_kernel_dispatch_id_t const &v) const {
+        size_t ret = 0;
+        util::hash_combine(ret, v.value);
+        return ret;
+    }
+};
+
+} // namespace std
+
+struct disassembly_ctx_t {
+    disassembly_ctx_t();
+    ~disassembly_ctx_t();
+
+    void disassemble_kernels(bool const reinitialize);
+    void init();
+    bool inited() const;
+    void reset();
+
+    amd_dbgapi_process_id_t process_id;
+    std::map
+      < amd_dbgapi_global_address_t
+      , amd::debug_agent::code_object_t
+      > codeobjs;
+};
+
+disassembly_ctx_t::disassembly_ctx_t()
+: process_id(AMD_DBGAPI_PROCESS_NONE)
+, codeobjs()
+{}
+
+disassembly_ctx_t::~disassembly_ctx_t()
+{
+    reset();
+}
+
+void
+disassembly_ctx_t::disassemble_kernels(bool const reinitialize)
+{
+    if (reinitialize) {
+        reset();
+    }
+    if (!inited()) {
+        init();
+    }
+
+    auto it = codeobjs.begin();
+    auto const end = codeobjs.end();
+    auto const pred = [](decltype(*it) &x){
+        /*
+         * A lame filter for the kernels in the current file, because nothing
+         * else in this little demo will have the URL prefix of `file://`.
+         */
+        return x.second.m_uri.find("file://", 0, 7) != std::string::npos;
+    };
+    while (end != (it = std::find_if(it, end, pred))) {
+        auto &codeobj = it->second;
+        codeobj.load_symbol_map();
+        if (!codeobj.m_symbol_map) {
+            fputs(PROGNAME ": error: failed to load symbol map\n", stderr);
+            break;
+        }
+
+        for (auto const &sym : *codeobj.m_symbol_map) {
+            auto const &addr = sym.first;
+            ::disassemble(disassembly_mode::KERNEL, process_id, codeobjs, addr);
+        }
+
+        ++it;
+    }
+}
+
+inline void
+disassembly_ctx_t::init()
+{
+    std::tie(process_id, codeobjs) = init_disassembly();
+}
+
+inline bool
+disassembly_ctx_t::inited() const
+{
+    return AMD_DBGAPI_PROCESS_NONE != process_id;
+}
+
+void
+disassembly_ctx_t::reset()
+{
+    codeobjs.clear();
+    if (AMD_DBGAPI_PROCESS_NONE.handle != process_id.handle) {
+        amd_dbgapi_process_detach(process_id);
+        amd_dbgapi_finalize();
+        process_id = AMD_DBGAPI_PROCESS_NONE;
+    }
+}
+
+static disassembly_ctx_t g_dis;
+
+void
+disassembly_disassemble_kernels(bool const reinitialize)
+{
+    g_dis.disassemble_kernels(reinitialize);
+}
+
+void
+disassembly_print_pc_sample_context(amd_dbgapi_global_address_t const pc)
+{
+    if (!g_dis.inited()) {
+        g_dis.init();
+    }
+    print_pc_context(g_dis.process_id, g_dis.codeobjs, pc);
+}

projects/rocprofiler/samples/pcsampler/code_printing_sample/disassembly.hpp

@@ -0,0 +1,32 @@
+/* Copyright (c) 2022 Advanced Micro Devices, Inc.
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE. */
+
+#ifndef SAMPLES_PCSAMPLER_CODE_PRINTING_SAMPLE_DISASSEMBLY_HPP_
+#define SAMPLES_PCSAMPLER_CODE_PRINTING_SAMPLE_DISASSEMBLY_HPP_
+
+#include <amd-dbgapi/amd-dbgapi.h>
+
+void
+disassembly_disassemble_kernels(bool const);
+
+void
+disassembly_print_pc_sample_context(amd_dbgapi_global_address_t const);
+
+#endif // SAMPLES_PCSAMPLER_CODE_PRINTING_SAMPLE_DISASSEMBLY_HPP_

projects/rocprofiler/samples/pcsampler/code_printing_sample/main.cpp

@@ -0,0 +1,447 @@
+/* Copyright (c) 2022 Advanced Micro Devices, Inc.
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE. */
+
+#include <algorithm>
+#include <chrono>
+#include <memory>
+#include <numeric>
+#include <vector>
+#include <cfloat>
+#include <cinttypes>
+#include <cstdint>
+#include <cstdlib>
+
+#include <unistd.h>
+
+#include <hip/hip_runtime.h>
+#include <hsa/hsa.h>
+
+#include <rocprofiler.h>
+
+#include "program.hpp"
+#include "program_options.hpp"
+#include "disassembly.hpp"
+
+#define XSTR(x) STR(x)
+#define STR(x) #x
+#define DBL_FMT "." XSTR(DBL_DECIMAL_DIG) "f"
+
+namespace util {
+
+struct hipMalloc_freer {
+    void operator()(void * const ptr) { (void)hipFree(ptr); }
+};
+
+} // namespace util
+
+namespace prng {
+
+static uint64_t
+splitmix64_next(uint64_t * const sm64_state)
+{
+    uint64_t z = (*sm64_state += 0x9e3779b97f4a7c15);
+    z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9;
+    z = (z ^ (z >> 27)) * 0x94d049bb133111eb;
+    return z ^ (z >> 31);
+}
+
+static inline uint64_t
+rotl64(const uint64_t x, int k)
+{
+    return (x << k) | (x >> (64 - k));
+}
+
+static uint64_t
+xrs_next(uint64_t * const xrs_state)
+{
+    const uint64_t result =
+      rotl64(xrs_state[0] + xrs_state[3], 23) + xrs_state[0];
+
+    const uint64_t t = xrs_state[1] << 17;
+
+    xrs_state[2] ^= xrs_state[0];
+    xrs_state[3] ^= xrs_state[1];
+    xrs_state[1] ^= xrs_state[2];
+    xrs_state[0] ^= xrs_state[3];
+
+    xrs_state[2] ^= t;
+
+    xrs_state[3] = rotl64(xrs_state[3], 45);
+
+    return result;
+}
+
+} // namespace prng
+
+namespace kernel {
+
+template <typename T>
+__global__ static void
+memset_gpu(T * const s, T const c, size_t const n)
+{
+    size_t i_start = threadIdx.x + blockIdx.x * blockDim.x;
+    size_t i_shift = blockDim.x * gridDim.x;
+    for (size_t i = i_start; i < n; i += i_shift) {
+        s[i] = c;
+    }
+}
+
+template <typename T>
+__global__ static void
+count_gpu(
+  T const * const xs,
+  T * const out,
+  size_t const n,
+  size_t const nblocks,
+  T const gt)
+{
+    size_t i_start = threadIdx.x + blockIdx.x * blockDim.x;
+    size_t i_shift = blockDim.x * gridDim.x;
+    for (size_t i = i_start; i < n; i += i_shift) {
+        if (xs[i] > gt) {
+            atomicAdd(&out[i % nblocks], 1);
+        }
+    }
+}
+
+} // namespace kernel
+
+static char const GETOPT_ARGS[] = "cd:mn:DP";
+
+static void
+usage()
+{
+    fputs("usage: " PROGNAME " [OPTION]... MIN [SEED]\n"
+          "  -d DEV\tHIP device number\n"
+          "  -n LEN\tLength of random integer array\n"
+          "  -D\t\tPrint kernel disassembly\n"
+          "  -P\t\tPrint source and disassembly of sampled PC locations\n"
+          "where\n"
+          "  DEV : i32\n"
+          "  MIN : u64\n"
+          "  LEN : u64\n"
+          "  SEED : u64\n",
+          stderr);
+}
+
+static int
+get_options(int argc, char **argv, program_options * const opts)
+{
+    int opt;
+
+    while (-1 != (opt = getopt(argc, argv, GETOPT_ARGS))) {
+        switch (opt) {
+        case 'd':
+            // TODO error checking
+            opts->device = strtol(optarg, nullptr, 10);
+            break;
+        case 'n':
+            // TODO error checking
+            opts->rands_len = strtoul(optarg, nullptr, 10);
+            break;
+        case 'D':
+            opts->disassemble = true;
+            break;
+        case 'P':
+            opts->pc_sampling = true;
+            break;
+        default:
+            usage();
+            return EXIT_FAILURE;
+        }
+    }
+
+    auto const optcount = argc - optind;
+    if (!(1 == optcount || 2 == optcount)) {
+        usage();
+        return EXIT_FAILURE;
+    }
+
+    // TODO error checking
+    opts->gt = strtoul(argv[optind], nullptr, 10);
+    if (2 == argc - optind) {
+        opts->seed = strtoull(argv[optind + 1], nullptr, 10);
+    }
+
+    return EXIT_SUCCESS;
+}
+
+static program_options g_opts;
+
+static void
+callback_flush_fn(
+  rocprofiler_record_header_t const *record,
+  rocprofiler_record_header_t const *end_record,
+  rocprofiler_session_id_t session_id,
+  rocprofiler_buffer_id_t buffer_id)
+{
+    while (record < end_record) {
+        if (nullptr == record) {
+            break;
+        }
+        if (ROCPROFILER_PC_SAMPLING_RECORD == record->kind) {
+            auto const &pcr = (rocprofiler_record_pc_sample_t &)*record;
+            printf(
+              "dispatch[%" PRIu64 "] timestamp(%" PRIu64
+              ") gpu_id(%#" PRIx64 ") pc-sample(%#" PRIx64
+              ") se(%" PRIu32 ")\n",
+              pcr.pc_sample.dispatch_id.value,
+              pcr.pc_sample.timestamp.value,
+              pcr.pc_sample.gpu_id.handle,
+              pcr.pc_sample.pc,
+              pcr.pc_sample.se);
+            if (g_opts.pc_sampling) {
+                disassembly_print_pc_sample_context(pcr.pc_sample.pc);
+            }
+        }
+        rocprofiler_next_record(record, &record, session_id, buffer_id);
+    }
+}
+
+static int
+run_kernel(program_options const &opts)
+{
+    rocprofiler_session_id_t sid;
+    rocprofiler_filter_id_t fid, fid2;
+    rocprofiler_buffer_id_t bid;
+    auto rocprofiler_ok = ROCPROFILER_STATUS_SUCCESS;
+
+    if (opts.pc_sampling) {
+        ROCPROFILER_CHECK(
+          rocprofiler_create_session(ROCPROFILER_NONE_REPLAY_MODE, &sid),
+          rocprofiler_ok);
+        if (ROCPROFILER_STATUS_SUCCESS != rocprofiler_ok) {
+            fputs("error: failed to create rocmtools session\n", stderr);
+            return EXIT_FAILURE;
+        }
+
+        rocprofiler_filter_property_t property{};
+
+        ROCPROFILER_CHECK(
+          rocprofiler_create_buffer(
+            sid, callback_flush_fn, static_cast<size_t>(0x1000), &bid),
+          rocprofiler_ok);
+        if (ROCPROFILER_STATUS_SUCCESS != rocprofiler_ok) {
+            fputs("error: failed to add PC sampling session mode\n", stderr);
+            goto out;
+        }
+
+        ROCPROFILER_CHECK(
+          rocprofiler_create_filter(
+            sid, ROCPROFILER_PC_SAMPLING_COLLECTION,
+            rocprofiler_filter_data_t{},
+            0, &fid, property),
+          rocprofiler_ok);
+        if (ROCPROFILER_STATUS_SUCCESS != rocprofiler_ok) {
+            goto cleanup;
+        }
+
+        ROCPROFILER_CHECK(
+          rocprofiler_create_filter(
+            sid, ROCPROFILER_DISPATCH_TIMESTAMPS_COLLECTION,
+            rocprofiler_filter_data_t{},
+            0, &fid2, property),
+          rocprofiler_ok);
+        if (ROCPROFILER_STATUS_SUCCESS != rocprofiler_ok) {
+            goto cleanup;
+        }
+
+        ROCPROFILER_CHECK(
+          rocprofiler_set_filter_buffer(sid, fid, bid),
+          rocprofiler_ok);
+        if (ROCPROFILER_STATUS_SUCCESS != rocprofiler_ok) {
+            goto cleanup;
+        }
+
+        ROCPROFILER_CHECK(
+          rocprofiler_set_filter_buffer(sid, fid2, bid),
+          rocprofiler_ok);
+        if (ROCPROFILER_STATUS_SUCCESS != rocprofiler_ok) {
+            goto cleanup;
+        }
+
+        ROCPROFILER_CHECK(
+          rocprofiler_start_session(sid),
+          rocprofiler_ok);
+        if (ROCPROFILER_STATUS_SUCCESS != rocprofiler_ok) {
+            goto cleanup;
+        }
+    }
+
+    {
+    printf("seed = %" PRIu64 "\n", opts.seed);
+
+    std::vector<uint64_t> rands(opts.rands_len);
+    using rands_elt_t = decltype(rands)::value_type;
+
+    uint64_t
+      sm64_state = opts.seed,
+      xrs_state[4];
+
+    {
+        using prng::splitmix64_next;
+        using prng::xrs_next;
+
+        // Initialize the Xoroshiro PRNG
+        xrs_state[0] = splitmix64_next(&sm64_state);
+        xrs_state[1] = splitmix64_next(&sm64_state);
+        xrs_state[2] = splitmix64_next(&sm64_state);
+        xrs_state[3] = splitmix64_next(&sm64_state);
+
+        // Fill rands with random integers
+        for (auto &i : rands) {
+            i = xrs_next(xrs_state);
+        }
+    }
+
+    struct tm {
+        using monoclk = std::chrono::steady_clock;
+        using dur = std::chrono::duration<double>;
+    };
+
+    using util::hipMalloc_freer;
+
+    auto const begin_time = tm::monoclk::now();
+
+    auto hip_ok = hipSuccess;
+    do {
+        HIP_CHECK_BREAK(hipSetDevice(opts.device), hip_ok);
+
+        auto const rands_nbytes = rands.size() * sizeof(rands_elt_t);
+        std::unique_ptr<rands_elt_t, hipMalloc_freer> rands_gpu;
+        {
+            rands_elt_t *rands_gpu_ptr;
+            HIP_CHECK_BREAK(hipMalloc(&rands_gpu_ptr, rands_nbytes), hip_ok);
+            rands_gpu.reset(rands_gpu_ptr);
+        }
+
+        HIP_CHECK_BREAK(
+          hipMemcpy(rands_gpu.get(), rands.data(), rands_nbytes,
+                    hipMemcpyHostToDevice),
+          hip_ok);
+        (void)hipDeviceSynchronize();
+
+        uint32_t constexpr nthreads = 256U;
+        uint32_t const nblocks = (rands.size() + nthreads - 1) / nthreads;
+
+        using count_elt_t = size_t;
+
+        auto const count_subtotals_nbytes = nblocks * sizeof(count_elt_t);
+        std::unique_ptr<count_elt_t, hipMalloc_freer> count_subtotals_gpu;
+        {
+            count_elt_t *count_subtotals_gpu_ptr;
+            HIP_CHECK_BREAK(
+              hipMalloc(&count_subtotals_gpu_ptr, count_subtotals_nbytes),
+              hip_ok);
+            count_subtotals_gpu.reset(count_subtotals_gpu_ptr);
+        }
+
+        hipLaunchKernelGGL(
+          kernel::memset_gpu, nblocks, nthreads, 0, 0,
+          count_subtotals_gpu.get(), 0UL, static_cast<size_t>(nblocks));
+        HIP_CHECK_BREAK(hipGetLastError(), hip_ok);
+        (void)hipDeviceSynchronize();
+
+        auto const kernel_begin_time = tm::monoclk::now();
+
+        hipLaunchKernelGGL(
+          kernel::count_gpu, nblocks, nthreads, 0, 0,
+          rands_gpu.get(), count_subtotals_gpu.get(), rands.size(),
+          static_cast<size_t>(nblocks), opts.gt);
+        HIP_CHECK_BREAK(hipGetLastError(), hip_ok);
+        (void)hipDeviceSynchronize();
+
+        auto const kernel_end_time = tm::monoclk::now();
+
+        std::vector<size_t> count_subtotals(nblocks);
+        HIP_CHECK_BREAK(
+          hipMemcpy(count_subtotals.data(), count_subtotals_gpu.get(),
+                    count_subtotals_nbytes, hipMemcpyDeviceToHost),
+          hip_ok);
+        (void)hipDeviceSynchronize();
+
+        // TODO parallel sum on GPU
+        auto const total =
+          std::accumulate(
+            count_subtotals.cbegin(), count_subtotals.cend(),
+            static_cast<size_t>(0));
+
+        auto const all_end_time = tm::monoclk::now();
+
+        tm::dur const kernel_time(kernel_end_time - kernel_begin_time);
+        auto total_time(all_end_time - begin_time);
+        tm::dur const total_time_without_tool_init(total_time);
+        printf("len(rands) = %zu; gt = %zu; count(rands, gt) = %zu\n"
+               "main kernel time elapsed: %" DBL_FMT "\n"
+               "full time elapsed: %" DBL_FMT "\n",
+               rands.size(), opts.gt, total,
+               kernel_time.count(),
+               total_time_without_tool_init.count());
+    } while (false);
+
+    if (opts.disassemble) {
+        disassembly_disassemble_kernels(false);
+    }
+    }
+
+cleanup:
+    if (opts.pc_sampling) {
+        rocprofiler_terminate_session(sid);
+        rocprofiler_flush_data(sid, bid);
+        rocprofiler_destroy_session(sid);
+    }
+
+out:
+    return ROCPROFILER_STATUS_SUCCESS == rocprofiler_ok
+      ? EXIT_SUCCESS
+      : EXIT_FAILURE;
+}
+
+int
+main(int argc, char **argv)
+{
+    if (auto const ret = get_options(argc, argv, &g_opts);
+        EXIT_SUCCESS != ret)
+    {
+        return ret;
+    }
+
+    if (hsa_init() != HSA_STATUS_SUCCESS){
+        return EXIT_FAILURE;
+    }
+
+    int ret = EXIT_FAILURE;
+    auto ok = ROCPROFILER_STATUS_SUCCESS;
+
+    ROCPROFILER_CHECK(rocprofiler_initialize(), ok);
+    if (ROCPROFILER_STATUS_SUCCESS == ok) {
+        ret = run_kernel(g_opts);
+    } else {
+        goto out;
+    }
+
+    rocprofiler_finalize();
+
+out:
+    hsa_shut_down();
+    return ROCPROFILER_STATUS_SUCCESS == ok && EXIT_FAILURE != ret
+      ? EXIT_SUCCESS
+      : EXIT_FAILURE;
+}

projects/rocprofiler/samples/pcsampler/code_printing_sample/program.hpp

@@ -0,0 +1,54 @@
+/* Copyright (c) 2022 Advanced Micro Devices, Inc.
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE. */
+
+#ifndef SAMPLES_PCSAMPLER_CODE_PRINTING_SAMPLE_PROGRAM_HPP_
+#define SAMPLES_PCSAMPLER_CODE_PRINTING_SAMPLE_PROGRAM_HPP_
+
+#define PROGNAME "code_printing_sample"
+
+#define HIP_ERROR(code)                                                 \
+    do {                                                                \
+        fprintf(stderr,                                                 \
+                PROGNAME ": Assertion failed at %s:%d, HIP error: %s\n", \
+                __FILE__, __LINE__, hipGetErrorString((code)));         \
+        fflush(stderr);                                                 \
+    } while (false);
+
+#define HIP_CHECK_BREAK(expr, var)                                      \
+    if (auto const code = (expr); hipSuccess != code) {                 \
+        HIP_ERROR(code);                                                \
+        (var) = code;                                                   \
+        break;                                                          \
+    }
+
+#define ROCPROFILER_ERROR(code)                                           \
+    do {                                                                \
+        fprintf(stderr,                                                 \
+                PROGNAME ": Assertion failed at %s:%d, ROCmtools error: %s\n", \
+                __FILE__, __LINE__, rocprofiler_error_str(code));      \
+        fflush(stderr);                                                 \
+    } while (false);
+
+#define ROCPROFILER_CHECK(expr, var)                                      \
+    if ((var) = (expr); ROCPROFILER_STATUS_SUCCESS != (var)) {            \
+        ROCPROFILER_ERROR((var));                                         \
+    }
+
+#endif // SAMPLES_PCSAMPLER_CODE_PRINTING_SAMPLE_PROGRAM_HPP_

projects/rocprofiler/samples/pcsampler/code_printing_sample/program_options.hpp

@@ -0,0 +1,49 @@
+/* Copyright (c) 2022 Advanced Micro Devices, Inc.
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE. */
+
+#ifndef SAMPLES_PCSAMPLER_CODE_PRINTING_SAMPLE_PROGRAM_OPTIONS_HPP_
+#define SAMPLES_PCSAMPLER_CODE_PRINTING_SAMPLE_PROGRAM_OPTIONS_HPP_
+
+#include <chrono>
+#include <cstdint>
+
+struct program_options {
+    program_options()
+    : device(0)
+    , no_gpu(false)
+    , hip_memset(false)
+    , rands_len(1024 * 1024 * 4)
+    , gt(0)
+    , seed(std::chrono::steady_clock::now().time_since_epoch().count())
+    , disassemble(false)
+    , pc_sampling(false)
+    {}
+
+    int device;
+    bool no_gpu;
+    bool hip_memset;
+    size_t rands_len;
+    uint64_t gt;
+    uint64_t seed;
+    bool disassemble;
+    bool pc_sampling;
+};
+
+#endif // SAMPLES_PCSAMPLER_CODE_PRINTING_SAMPLE_PROGRAM_OPTIONS_HPP_

projects/rocprofiler/samples/profiler/application_replay_sample.cpp

@@ -0,0 +1,72 @@
+#include "../common/common.h"
+
+int main(int argc, char** argv) {
+  printf("APPLICATION REPLAY Mode is not yet Supported!");
+#if 0
+  int* gpuMem;
+  prepare();
+  // Initialize the tools
+  CHECK_ROCPROFILER(rocprofiler_initialize());
+
+  // Creating the session with given replay mode
+  rocprofiler_session_id_t session_id;
+  CHECK_ROCPROFILER(rocprofiler_create_session(ROCPROFILER_APPLICATION_REPLAY_MODE, &session_id));
+
+  // Creating Output Buffer for the data
+  rocprofiler_buffer_id_t buffer_id;
+  CHECK_ROCPROFILER(rocprofiler_create_buffer(
+      session_id,
+      [](const rocprofiler_record_header_t* record, const rocprofiler_record_header_t* end_record,
+         rocprofiler_session_id_t session_id, rocprofiler_buffer_id_t buffer_id) {
+        WriteBufferRecords(record, end_record, session_id, buffer_id);
+      },
+      0x9999, &buffer_id));
+
+  // Counter Collection Filter
+  std::vector<const char*> counters;
+  counters.emplace_back("GRBM_COUNT");
+  rocprofiler_filter_id_t filter_id;
+  [[maybe_unused]] rocprofiler_filter_property_t property = {};
+  CHECK_ROCPROFILER(rocprofiler_create_filter(session_id, ROCPROFILER_COUNTERS_COLLECTION,
+                                          rocprofiler_filter_data_t{.counters_names = &counters[0]},
+                                          counters.size(), &filter_id, property));
+  CHECK_ROCPROFILER(rocprofiler_set_filter_buffer(session_id, filter_id, buffer_id));
+  filter_ids.emplace_back(filter_id);
+
+  // Normal HIP Calls
+  hipDeviceProp_t devProp;
+  HIP_CALL(hipGetDeviceProperties(&devProp, 0));
+  HIP_CALL(hipMalloc((void**)&gpuMem, 1 * sizeof(int)));
+
+  // KernelA and KernelB won't be profiled
+  kernelCalls('A');
+  kernelCalls('B');
+
+  // Activating Profiling Session to profile whatever kernel launches occurs up
+  // till the next terminate session
+  CHECK_ROCPROFILER(rocprofiler_start_session(session_id));
+
+  // KernelC, KernelD, KernelE and KernelF to be profiled as part of the session
+  kernelCalls('C');
+  kernelCalls('D');
+  kernelCalls('E');
+  kernelCalls('F');
+  // Normal HIP Calls
+  HIP_CALL(hipFree(gpuMem));
+
+  // Deactivating session
+  CHECK_ROCPROFILER(rocprofiler_terminate_session(session_id));
+
+  // Manual Flush user buffer request
+  CHECK_ROCPROFILER(rocprofiler_flush_data(session_id, buffer_id));
+
+  // Destroy sessions
+  CHECK_ROCPROFILER(rocprofiler_destroy_session(session_id));
+
+  // Destroy all profiling related objects(User buffer, sessions, filters,
+  // etc..)
+  CHECK_ROCPROFILER(rocprofiler_finalize());
+#endif
+
+  return 0;
+}

projects/rocprofiler/samples/profiler/device_profiling_sample.cpp

@@ -0,0 +1,61 @@
+#include "../common/common.h"
+#include <chrono>
+#include <thread>
+#include <iostream>
+
+#include "rocprofiler.h"
+
+int main(int argc, char** argv) {
+  int poll_duration = 5;
+  if (argc > 1) poll_duration = atoi(argv[1]);
+
+  CHECK_ROCPROFILER(rocprofiler_initialize());
+  printf("initialize\n");
+
+  rocprofiler_session_id_t dp_session_id;
+  std::vector<const char*> counters;
+  counters.emplace_back("FETCH_SIZE");
+
+  printf("session create\n");
+
+  int gpu_agent = 0;
+  int cpu_agent = 0;
+  CHECK_ROCPROFILER(rocprofiler_device_profiling_session_create(&counters[0], counters.size(),
+                                                            &dp_session_id, gpu_agent, cpu_agent));
+
+  printf("session start \n");
+  // start GPU device profiling
+  CHECK_ROCPROFILER(rocprofiler_device_profiling_session_start(dp_session_id));
+
+  using std::chrono::duration_cast;
+  using std::chrono::high_resolution_clock;
+  using std::chrono::milliseconds;
+
+  auto t1 = high_resolution_clock::now();
+
+  do {
+    printf("polling\n");
+    std::vector<rocprofiler_device_profile_metric_t> data(counters.size());
+    // Poll metrics
+    CHECK_ROCPROFILER(rocprofiler_device_profiling_session_poll(dp_session_id, &data[0]));
+
+    for (size_t i = 0; i < data.size(); i++)
+      std::cout << data[i].metric_name << ": " << data[i].value.value << std::endl;
+    std::this_thread::sleep_for(std::chrono::milliseconds(1));
+    // break;
+  } while (--poll_duration > 0);
+
+  auto t2 = high_resolution_clock::now();
+  /* Getting number of milliseconds as an integer. */
+  auto ms_int = duration_cast<milliseconds>(t2 - t1);
+
+  std::cout << ms_int.count() << "ms\n";
+
+  // Stop session
+  CHECK_ROCPROFILER(rocprofiler_device_profiling_session_stop(dp_session_id));
+
+  // Destroy session
+  CHECK_ROCPROFILER(rocprofiler_device_profiling_session_destroy(dp_session_id));
+
+  return 0;
+}

projects/rocprofiler/samples/profiler/kernel_replay_sample.cpp

@@ -0,0 +1,68 @@
+#include "../common/common.h"
+
+int main(int argc, char** argv) {
+  int* gpuMem;
+  prepare();
+  // Initialize the tools
+  CHECK_ROCPROFILER(rocprofiler_initialize());
+
+  // Creating the session with given replay mode
+  rocprofiler_session_id_t session_id;
+  CHECK_ROCPROFILER(rocprofiler_create_session(ROCPROFILER_KERNEL_REPLAY_MODE, &session_id));
+
+  // Creating Output Buffer for the data
+  rocprofiler_buffer_id_t buffer_id;
+  CHECK_ROCPROFILER(rocprofiler_create_buffer(
+      session_id,
+      [](const rocprofiler_record_header_t* record, const rocprofiler_record_header_t* end_record,
+         rocprofiler_session_id_t session_id, rocprofiler_buffer_id_t buffer_id) {
+        WriteBufferRecords(record, end_record, session_id, buffer_id);
+      },
+      0x9999, &buffer_id));
+
+  // Counter Collection Filter
+  std::vector<const char*> counters;
+  counters.emplace_back("GRBM_COUNT");
+  rocprofiler_filter_id_t filter_id;
+  [[maybe_unused]] rocprofiler_filter_property_t property = {};
+  CHECK_ROCPROFILER(rocprofiler_create_filter(session_id, ROCPROFILER_COUNTERS_COLLECTION,
+                                          rocprofiler_filter_data_t{.counters_names = &counters[0]},
+                                          counters.size(), &filter_id, property));
+  CHECK_ROCPROFILER(rocprofiler_set_filter_buffer(session_id, filter_id, buffer_id));
+
+  // Normal HIP Calls
+  hipDeviceProp_t devProp;
+  HIP_CALL(hipGetDeviceProperties(&devProp, 0));
+  HIP_CALL(hipMalloc((void**)&gpuMem, 1 * sizeof(int)));
+
+  // KernelA and KernelB won't be profiled
+  kernelCalls('A');
+  kernelCalls('B');
+
+  // Activating Profiling Session to profile whatever kernel launches occurs up
+  // till the next terminate session
+  CHECK_ROCPROFILER(rocprofiler_start_session(session_id));
+
+  // KernelC, KernelD, KernelE and KernelF to be profiled as part of the session
+  kernelCalls('C');
+  kernelCalls('D');
+  kernelCalls('E');
+  kernelCalls('F');
+  // Normal HIP Calls
+  HIP_CALL(hipFree(gpuMem));
+
+  // Deactivating session
+  CHECK_ROCPROFILER(rocprofiler_terminate_session(session_id));
+
+  // Manual Flush user buffer request
+  CHECK_ROCPROFILER(rocprofiler_flush_data(session_id, buffer_id));
+
+  // Destroy sessions
+  CHECK_ROCPROFILER(rocprofiler_destroy_session(session_id));
+
+  // Destroy all profiling related objects(User buffer, sessions, filters,
+  // etc..)
+  CHECK_ROCPROFILER(rocprofiler_finalize());
+
+  return 0;
+}

projects/rocprofiler/samples/profiler/user_replay_sample.cpp

@@ -0,0 +1,78 @@
+#include "../common/common.h"
+
+int main(int argc, char** argv) {
+  printf("USER REPLAY Mode is not yet Supported!");
+#if 0
+  int* gpuMem;
+  prepare();
+  // Initialize the tools
+  CHECK_ROCPROFILER(rocprofiler_initialize());
+
+  // Creating the session with given replay mode
+  rocprofiler_session_id_t session_id;
+  CHECK_ROCPROFILER(rocprofiler_create_session(ROCPROFILER_USER_REPLAY_MODE, &session_id));
+
+  // Creating Output Buffer for the data
+  rocprofiler_buffer_id_t buffer_id;
+  CHECK_ROCPROFILER(rocprofiler_create_buffer(
+      session_id,
+      [](const rocprofiler_record_header_t* record, const rocprofiler_record_header_t* end_record,
+         rocprofiler_session_id_t session_id, rocprofiler_buffer_id_t buffer_id) {
+        WriteBufferRecords(record, end_record, session_id, buffer_id);
+      },
+      0x9999, &buffer_id));
+
+  // Counter Collection Filter
+  std::vector<const char*> counters;
+  counters.emplace_back("GRBM_COUNT");
+  rocprofiler_filter_id_t filter_id;
+  [[maybe_unused]] rocprofiler_filter_property_t property = {};
+  CHECK_ROCPROFILER(rocprofiler_create_filter(session_id, ROCPROFILER_COUNTERS_COLLECTION,
+                                          rocprofiler_filter_data_t{.counters_names = &counters[0]},
+                                          counters.size(), &filter_id, property));
+  CHECK_ROCPROFILER(rocprofiler_set_filter_buffer(session_id, filter_id, buffer_id));
+  filter_ids.emplace_back(filter_id);
+
+  // Normal HIP Calls
+  hipDeviceProp_t devProp;
+  HIP_CALL(hipGetDeviceProperties(&devProp, 0));
+  HIP_CALL(hipMalloc((void**)&gpuMem, 1 * sizeof(int)));
+
+  // KernelA and KernelB won't be profiled
+  kernelCalls('A');
+  kernelCalls('B');
+
+  // Activating Profiling Session to profile whatever kernel launches occurs up
+  // till the next terminate session
+  CHECK_ROCPROFILER(rocprofiler_start_session(session_id));
+
+  // Replay Pass Start point
+  CHECK_ROCPROFILER(rocprofiler_start_replay_pass());
+
+  // KernelC, KernelD, KernelE and KernelF to be profiled as part of the session
+  kernelCalls('C');
+  kernelCalls('D');
+  kernelCalls('E');
+  kernelCalls('F');
+  // Normal HIP Calls
+  HIP_CALL(hipFree(gpuMem));
+
+  // Deactivating session
+  CHECK_ROCPROFILER(rocprofiler_terminate_session(session_id));
+
+  // Manual Flush user buffer request
+  CHECK_ROCPROFILER(rocprofiler_flush_data(session_id, buffer_id));
+
+  // Replay Pass End point
+  CHECK_ROCPROFILER(rocprofiler_end_replay_pass());
+
+  // Destroy sessions
+  CHECK_ROCPROFILER(rocprofiler_destroy_session(session_id));
+
+  // Destroy all profiling related objects(User buffer, sessions, filters,
+  // etc..)
+  CHECK_ROCPROFILER(rocprofiler_finalize());
+#endif
+
+  return 0;
+}

projects/rocprofiler/samples/run_samples.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+CURRENT_DIR="$( dirname -- "$0"; )";
+
+echo -e "Running Samples"
+
+export ROCPROFILER_METRICS_PATH=${CURRENT_DIR}/../counters/derived_counters.xml
+
+echo -e "\tProfiler Samples:"
+
+# echo -e "\t\tApplication Replay Sample:"
+# eval ${CURRENT_DIR}/profiler_application_replay
+
+echo -e "\t\tKernel Replay Sample:"
+eval ${CURRENT_DIR}/profiler_kernel_replay
+
+# echo -e "\t\tUser Replay Sample:"
+# eval ${CURRENT_DIR}/profiler_user_replay
+
+echo -e "\t\tDevice Profiling Sample:"
+eval ${CURRENT_DIR}/profiler_device_profiling
+
+
+
+# echo -e "\tTracer Samples:"
+
+
+# echo -e "\t\tHIP/HSA Trace Sample:"
+# eval ${CURRENT_DIR}/tracer_hip_hsa

projects/rocprofiler/samples/tracer/sample.cpp

@@ -0,0 +1,82 @@
+#include "../common/common.h"
+
+int main(int argc, char** argv) {
+  int* gpuMem;
+  prepare();
+  // Initialize the tools
+  CHECK_ROCPROFILER(rocprofiler_initialize());
+
+  // Creating the session with given replay mode
+  rocprofiler_session_id_t session_id;
+  CHECK_ROCPROFILER(rocprofiler_create_session(ROCPROFILER_KERNEL_REPLAY_MODE, &session_id));
+
+  // Creating Output Buffer for the data
+  rocprofiler_buffer_id_t buffer_id;
+  CHECK_ROCPROFILER(rocprofiler_create_buffer(
+      session_id,
+      [](const rocprofiler_record_header_t* record, const rocprofiler_record_header_t* end_record,
+         rocprofiler_session_id_t session_id, rocprofiler_buffer_id_t buffer_id) {
+        WriteBufferRecords(record, end_record, session_id, buffer_id);
+      },
+      0x9999, &buffer_id));
+
+  // Tracing Filter
+  std::vector<rocprofiler_tracer_activity_domain_t> apis_requested;
+  apis_requested.emplace_back(ACTIVITY_DOMAIN_HIP_API);
+  apis_requested.emplace_back(ACTIVITY_DOMAIN_HIP_OPS);
+  apis_requested.emplace_back(ACTIVITY_DOMAIN_HSA_API);
+  apis_requested.emplace_back(ACTIVITY_DOMAIN_HSA_OPS);
+  apis_requested.emplace_back(ACTIVITY_DOMAIN_ROCTX);
+  rocprofiler_filter_id_t api_tracing_filter_id;
+  CHECK_ROCPROFILER(rocprofiler_create_filter(
+      session_id, ROCPROFILER_API_TRACE, rocprofiler_filter_data_t{&apis_requested[0]},
+      apis_requested.size(), &api_tracing_filter_id, rocprofiler_filter_property_t{}));
+  CHECK_ROCPROFILER(rocprofiler_set_filter_buffer(session_id, api_tracing_filter_id, buffer_id));
+  CHECK_ROCPROFILER(rocprofiler_set_api_trace_sync_callback(
+      session_id, api_tracing_filter_id,
+      [](rocprofiler_record_tracer_t record, rocprofiler_session_id_t session_id) {
+        FlushTracerRecord(record, session_id);
+      }));
+
+  // Kernel Tracing
+  rocprofiler_filter_id_t kernel_tracing_filter_id;
+  CHECK_ROCPROFILER(rocprofiler_create_filter(session_id, ROCPROFILER_DISPATCH_TIMESTAMPS_COLLECTION,
+                                          rocprofiler_filter_data_t{}, 0, &kernel_tracing_filter_id,
+                                          rocprofiler_filter_property_t{}));
+  CHECK_ROCPROFILER(rocprofiler_set_filter_buffer(session_id, kernel_tracing_filter_id, buffer_id));
+
+  // Normal HIP Calls won't be traced
+  hipDeviceProp_t devProp;
+  HIP_CALL(hipGetDeviceProperties(&devProp, 0));
+  HIP_CALL(hipMalloc((void**)&gpuMem, 1 * sizeof(int)));
+  // KernelA and KernelB won't be traced
+  kernelCalls('A');
+  kernelCalls('B');
+
+  // Activating Profiling Session to profile whatever kernel launches occurs up
+  // till the next terminate session
+  CHECK_ROCPROFILER(rocprofiler_start_session(session_id));
+
+  // KernelC, KernelD, KernelE and KernelF to be traced as part of the session
+  kernelCalls('C');
+  kernelCalls('D');
+  kernelCalls('E');
+  kernelCalls('F');
+  // Normal HIP Calls that will be traced
+  HIP_CALL(hipFree(gpuMem));
+
+  // Deactivating session
+  CHECK_ROCPROFILER(rocprofiler_terminate_session(session_id));
+
+  // Manual Flush user buffer request
+  CHECK_ROCPROFILER(rocprofiler_flush_data(session_id, buffer_id));
+
+  // Destroy sessions
+  CHECK_ROCPROFILER(rocprofiler_destroy_session(session_id));
+
+  // Destroy all profiling related objects(User buffer, sessions, filters,
+  // etc..)
+  CHECK_ROCPROFILER(rocprofiler_finalize());
+
+  return 0;
+}