PC Sampling: Add start stop and flush APIs

Create PC Sampling APIs for start and stop functions. And create stub
for flush function.

Change-Id: I7a093b29dc87e34ac06faaae6cac2be50e4663e1


[ROCm/ROCR-Runtime commit: a842247482]

projects/rocr-runtime/runtime/hsa-runtime/pcs/hsa_ven_amd_pc_sampling.cpp

@@ -134,6 +134,24 @@ hsa_status_t hsa_ven_amd_pcs_destroy(hsa_ven_amd_pcs_t handle) {
   CATCH;
 }
 
+hsa_status_t hsa_ven_amd_pcs_start(hsa_ven_amd_pcs_t handle) {
+  TRY;
+  return PcsRuntime::instance()->PcSamplingStart(handle);
+  CATCH;
+}
+
+hsa_status_t hsa_ven_amd_pcs_stop(hsa_ven_amd_pcs_t handle) {
+  TRY;
+  return PcsRuntime::instance()->PcSamplingStop(handle);
+  CATCH;
+}
+
+hsa_status_t hsa_ven_amd_pcs_flush(hsa_ven_amd_pcs_t handle) {
+  TRY;
+  return PcsRuntime::instance()->PcSamplingFlush(handle);
+  CATCH;
+}
+
 void LoadPcSampling(core::PcSamplingExtTableInternal* pcs_api) {
   pcs_api->hsa_ven_amd_pcs_iterate_configuration_fn = hsa_ven_amd_pcs_iterate_configuration;
   pcs_api->hsa_ven_amd_pcs_create_fn = hsa_ven_amd_pcs_create;

projects/rocr-runtime/runtime/hsa-runtime/pcs/inc/hsa_ven_amd_pc_sampling_impl.h

@@ -73,6 +73,12 @@ hsa_status_t hsa_ven_amd_pcs_create_from_id(
 
 hsa_status_t hsa_ven_amd_pcs_destroy(hsa_ven_amd_pcs_t pc_sampling);
 
+hsa_status_t hsa_ven_amd_pcs_start(hsa_ven_amd_pcs_t pc_sampling);
+
+hsa_status_t hsa_ven_amd_pcs_stop(hsa_ven_amd_pcs_t pc_sampling);
+
+hsa_status_t hsa_ven_amd_pcs_flush(hsa_ven_amd_pcs_t pc_sampling);
+
 // Update Api table with func pointers that implement functionality
 void LoadPcSampling(core::PcSamplingExtTableInternal* pcs_api);
 

projects/rocr-runtime/runtime/hsa-runtime/pcs/pcs_runtime.cpp

@@ -104,7 +104,7 @@ PcsRuntime::PcSamplingSession::PcSamplingSession(
     core::Agent* _agent, hsa_ven_amd_pcs_method_kind_t method, hsa_ven_amd_pcs_units_t units,
     size_t interval, size_t latency, size_t buffer_size,
     hsa_ven_amd_pcs_data_ready_callback_t data_ready_callback, void* client_callback_data)
-    : agent(_agent), thunkId_(0), valid_(true), sample_size_(0) {
+    : agent(_agent), thunkId_(0), active_(false), valid_(true), sample_size_(0) {
   switch (method) {
     case HSA_VEN_AMD_PCS_METHOD_HOSTTRAP_V1:
       sample_size_ = sizeof(perf_sample_hosttrap_v1_t);
@@ -240,6 +240,41 @@ hsa_status_t PcsRuntime::PcSamplingDestroy(hsa_ven_amd_pcs_t handle) {
   return ret;
 }
 
+hsa_status_t PcsRuntime::PcSamplingStart(hsa_ven_amd_pcs_t handle) {
+  ScopedAcquire<KernelMutex> lock(&pc_sampling_lock_);
+  auto pcSamplingSessionIt = pc_sampling_.find(reinterpret_cast<uint64_t>(handle.handle));
+  if (pcSamplingSessionIt == pc_sampling_.end()) {
+    debug_warning(false && "Cannot find PcSampling session");
+    return HSA_STATUS_ERROR_INVALID_ARGUMENT;
+  }
+  AMD::GpuAgentInt* gpu_agent = static_cast<AMD::GpuAgentInt*>(pcSamplingSessionIt->second.agent);
+
+  return gpu_agent->PcSamplingStart(pcSamplingSessionIt->second);
+}
+
+hsa_status_t PcsRuntime::PcSamplingStop(hsa_ven_amd_pcs_t handle) {
+  ScopedAcquire<KernelMutex> lock(&pc_sampling_lock_);
+  auto pcSamplingSessionIt = pc_sampling_.find(reinterpret_cast<uint64_t>(handle.handle));
+  if (pcSamplingSessionIt == pc_sampling_.end()) {
+    debug_warning(false && "Cannot find PcSampling session");
+    return HSA_STATUS_ERROR_INVALID_ARGUMENT;
+  }
+  AMD::GpuAgentInt* gpu_agent = static_cast<AMD::GpuAgentInt*>(pcSamplingSessionIt->second.agent);
+
+  return gpu_agent->PcSamplingStop(pcSamplingSessionIt->second);
+}
+
+hsa_status_t PcsRuntime::PcSamplingFlush(hsa_ven_amd_pcs_t handle) {
+  ScopedAcquire<KernelMutex> lock(&pc_sampling_lock_);
+  auto pcSamplingSessionIt = pc_sampling_.find(reinterpret_cast<uint64_t>(handle.handle));
+  if (pcSamplingSessionIt == pc_sampling_.end()) {
+    debug_warning(false && "Cannot find PcSampling session");
+    return HSA_STATUS_ERROR_INVALID_ARGUMENT;
+  }
+  AMD::GpuAgentInt* gpu_agent = static_cast<AMD::GpuAgentInt*>(pcSamplingSessionIt->second.agent);
+
+  return gpu_agent->PcSamplingFlush(pcSamplingSessionIt->second);
+}
 
 }  // namespace pcs
 }  // namespace rocr

projects/rocr-runtime/runtime/hsa-runtime/pcs/pcs_runtime.h

@@ -70,7 +70,7 @@ class PcsRuntime {
 
   class PcSamplingSession {
    public:
-    PcSamplingSession() : agent(NULL), thunkId_(0){};
+    PcSamplingSession() : agent(NULL), thunkId_(0), active_(false){};
     PcSamplingSession(core::Agent* agent, hsa_ven_amd_pcs_method_kind_t method,
                       hsa_ven_amd_pcs_units_t units, size_t interval, size_t latency,
                       size_t buffer_size, hsa_ven_amd_pcs_data_ready_callback_t data_ready_callback,
@@ -88,11 +88,15 @@ class PcsRuntime {
     core::Agent* agent;
     void SetThunkId(HsaPcSamplingTraceId thunkId) { thunkId_ = thunkId; }
     HsaPcSamplingTraceId ThunkId() { return thunkId_; }
+    bool isActive() { return active_; }
+    void start() { active_ = true; }
+    void stop() { active_ = false; }
 
    private:
     HsaPcSamplingTraceId thunkId_;
 
-    bool valid_;  // Whether configuration parameters are valid
+    bool active_;  // Set to true when the session is started
+    bool valid_;   // Whether configuration parameters are valid
     size_t sample_size_;
 
     struct client_session_data_t {
@@ -126,6 +130,9 @@ class PcsRuntime {
                                       void* client_cb_data, hsa_ven_amd_pcs_t* handle);
 
   hsa_status_t PcSamplingDestroy(hsa_ven_amd_pcs_t handle);
+  hsa_status_t PcSamplingStart(hsa_ven_amd_pcs_t handle);
+  hsa_status_t PcSamplingStop(hsa_ven_amd_pcs_t handle);
+  hsa_status_t PcSamplingFlush(hsa_ven_amd_pcs_t handle);
 
  private:
   /// @brief Initialize singleton object, must be called once.