Adding rocprofilerv2

Change-Id: Ic0cc280ba207d2b8f6ccae1cd4ac3184152fc1ad [ROCm/rocprofiler commit: 8032adb64f]
2023-02-03 12:31:39 -06:00
commit de4abd0d0f
@@ -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;
+}
@@ -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;
+}
@@ -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;
+}
@@ -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;
+}