ROC profiler prototype sources importing

[ROCm/rocprofiler commit: 85278f08a0]

projects/rocprofiler/test/util/helper_funcs.h

@@ -0,0 +1,87 @@
+/**********************************************************************
+Copyright ©2013 Advanced Micro Devices, Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted
+provided that the following conditions are met:
+
+•	Redistributions of source code must retain the above copyright notice, this list of
+conditions and the following disclaimer.
+•	Redistributions in binary form must reproduce the above copyright notice, this list of
+conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+********************************************************************/
+#ifndef TEST_UTIL_HELPER_FUNCS_H_
+#define TEST_UTIL_HELPER_FUNCS_H_
+
+#include <time.h>
+#include <cmath>
+#include <iostream>
+#include <sstream>
+#include <string>
+
+static inline void Error(std::string error_msg) {
+  std::cerr << "Error: " << error_msg << std::endl;
+}
+
+template <typename T>
+void PrintArray(const std::string header, const T* data, const int width, const int height) {
+  std::clog << header << " :\n";
+  for (int i = 0; i < height; i++) {
+    std::clog << "> ";
+    for (int j = 0; j < width; j++) {
+      std::clog << data[i * width + j] << " ";
+    }
+    std::clog << "\n";
+  }
+}
+
+template <typename T>
+bool FillRandom(T* array_ptr, const int width, const int height, const T range_min,
+                const T range_max, unsigned int seed = 123) {
+  if (!array_ptr) {
+    Error("Cannot fill array. NULL pointer.");
+    return false;
+  }
+
+  if (!seed) seed = (unsigned int)time(NULL);
+
+  srand(seed);
+  double range = double(range_max - range_min) + 1.0;
+
+  /* random initialisation of input */
+  for (int i = 0; i < height; i++)
+    for (int j = 0; j < width; j++) {
+      int index = i * width + j;
+      array_ptr[index] = range_min + T(range * rand() / (RAND_MAX + 1.0));
+    }
+
+  return true;
+}
+
+template <typename T> T RoundToPowerOf2(T val) {
+  int bytes = sizeof(T);
+
+  val--;
+  for (int i = 0; i < bytes; i++) val |= val >> (1 << i);
+  val++;
+
+  return val;
+}
+
+template <typename T> bool IsPowerOf2(T val) {
+  long long long_val = val;
+  return (((long_val & (-long_val)) - long_val == 0) && (long_val != 0));
+}
+
+#endif  // TEST_UTIL_HELPER_FUNCS_H_

projects/rocprofiler/test/util/hsa_rsrc_factory.cpp

@@ -0,0 +1,372 @@
+/**********************************************************************
+Copyright ©2013 Advanced Micro Devices, Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted
+provided that the following conditions are met:
+
+<95>    Redistributions of source code must retain the above copyright notice, this list of
+conditions and the following disclaimer.
+<95>    Redistributions in binary form must reproduce the above copyright notice, this list of
+conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+********************************************************************/
+
+#include "util/hsa_rsrc_factory.h"
+
+#include <hsa.h>
+#include <hsa_ext_finalize.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <cassert>
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <vector>
+
+// Callback function to find and bind kernarg region of an agent
+static hsa_status_t FindMemRegionsCallback(hsa_region_t region, void* data) {
+  hsa_region_global_flag_t flags;
+  hsa_region_segment_t segment_id;
+
+  hsa_region_get_info(region, HSA_REGION_INFO_SEGMENT, &segment_id);
+  if (segment_id != HSA_REGION_SEGMENT_GLOBAL) {
+    return HSA_STATUS_SUCCESS;
+  }
+
+  AgentInfo* agent_info = (AgentInfo*)data;
+  hsa_region_get_info(region, HSA_REGION_INFO_GLOBAL_FLAGS, &flags);
+  if (flags & HSA_REGION_GLOBAL_FLAG_COARSE_GRAINED) {
+    agent_info->coarse_region = region;
+  }
+
+  if (flags & HSA_REGION_GLOBAL_FLAG_KERNARG) {
+    agent_info->kernarg_region = region;
+  }
+
+  return HSA_STATUS_SUCCESS;
+}
+
+// Callback function to get the number of agents
+static hsa_status_t GetHsaAgentsCallback(hsa_agent_t agent, void* data) {
+  // Copy handle of agent and increment number of agents reported
+  HsaRsrcFactory* rsrcFactory = reinterpret_cast<HsaRsrcFactory*>(data);
+
+  // Determine if device is a Gpu agent
+  hsa_status_t status;
+  hsa_device_type_t type;
+  status = hsa_agent_get_info(agent, HSA_AGENT_INFO_DEVICE, &type);
+  CHECK_STATUS("Error Calling hsa_agent_get_info", status);
+  if (type == HSA_DEVICE_TYPE_DSP) {
+    return HSA_STATUS_SUCCESS;
+  }
+
+  if (type == HSA_DEVICE_TYPE_CPU) {
+    AgentInfo* agent_info = reinterpret_cast<AgentInfo*>(malloc(sizeof(AgentInfo)));
+    agent_info->dev_id = agent;
+    agent_info->dev_type = HSA_DEVICE_TYPE_CPU;
+    rsrcFactory->AddAgentInfo(agent_info, false);
+    return HSA_STATUS_SUCCESS;
+  }
+
+  // Device is a Gpu agent, build an instance of AgentInfo
+  AgentInfo* agent_info = reinterpret_cast<AgentInfo*>(malloc(sizeof(AgentInfo)));
+  agent_info->dev_id = agent;
+  agent_info->dev_type = HSA_DEVICE_TYPE_GPU;
+  hsa_agent_get_info(agent, HSA_AGENT_INFO_NAME, agent_info->name);
+  agent_info->max_wave_size = 0;
+  hsa_agent_get_info(agent, HSA_AGENT_INFO_WAVEFRONT_SIZE, &agent_info->max_wave_size);
+  agent_info->max_queue_size = 0;
+  hsa_agent_get_info(agent, HSA_AGENT_INFO_QUEUE_MAX_SIZE, &agent_info->max_queue_size);
+  agent_info->profile = hsa_profile_t(108);
+  hsa_agent_get_info(agent, HSA_AGENT_INFO_PROFILE, &agent_info->profile);
+
+  // Initialize memory regions to zero
+  agent_info->kernarg_region.handle = 0;
+  agent_info->coarse_region.handle = 0;
+
+  // Find and Bind Memory regions of the Gpu agent
+  hsa_agent_iterate_regions(agent, FindMemRegionsCallback, agent_info);
+
+  // Save the instance of AgentInfo
+  rsrcFactory->AddAgentInfo(agent_info, true);
+
+  return HSA_STATUS_SUCCESS;
+}
+
+// Constructor of the class
+HsaRsrcFactory::HsaRsrcFactory() {
+  // Initialize the Hsa Runtime
+  hsa_status_t status = hsa_init();
+  CHECK_STATUS("Error in hsa_init", status);
+
+  // Discover the set of Gpu devices available on the platform
+  status = hsa_iterate_agents(GetHsaAgentsCallback, this);
+  CHECK_STATUS("Error Calling hsa_iterate_agents", status);
+}
+
+// Destructor of the class
+HsaRsrcFactory::~HsaRsrcFactory() {
+  hsa_status_t status = hsa_shut_down();
+  CHECK_STATUS("Error in hsa_shut_down", status);
+}
+
+// Get the count of Hsa Gpu Agents available on the platform
+//
+// @return uint32_t Number of Gpu agents on platform
+//
+uint32_t HsaRsrcFactory::GetCountOfGpuAgents() { return uint32_t(gpu_list_.size()); }
+
+// Get the count of Hsa Cpu Agents available on the platform
+//
+// @return uint32_t Number of Cpu agents on platform
+//
+uint32_t HsaRsrcFactory::GetCountOfCpuAgents() { return uint32_t(cpu_list_.size()); }
+
+// Get the AgentInfo handle of a Gpu device
+//
+// @param idx Gpu Agent at specified index
+//
+// @param agent_info Output parameter updated with AgentInfo
+//
+// @return bool true if successful, false otherwise
+//
+bool HsaRsrcFactory::GetGpuAgentInfo(uint32_t idx, AgentInfo** agent_info) {
+  // Determine if request is valid
+  uint32_t size = uint32_t(gpu_list_.size());
+  if (idx >= size) {
+    return false;
+  }
+
+  // Copy AgentInfo from specified index
+  *agent_info = gpu_list_[idx];
+  return true;
+}
+
+// Get the AgentInfo handle of a Cpu device
+//
+// @param idx Cpu Agent at specified index
+//
+// @param agent_info Output parameter updated with AgentInfo
+//
+// @return bool true if successful, false otherwise
+//
+bool HsaRsrcFactory::GetCpuAgentInfo(uint32_t idx, AgentInfo** agent_info) {
+  // Determine if request is valid
+  uint32_t size = uint32_t(cpu_list_.size());
+  if (idx >= size) {
+    return false;
+  }
+
+  // Copy AgentInfo from specified index
+  *agent_info = cpu_list_[idx];
+  return true;
+}
+
+// Create a Queue object and return its handle. The queue object is expected
+// to support user requested number of Aql dispatch packets.
+//
+// @param agent_info Gpu Agent on which to create a queue object
+//
+// @param num_Pkts Number of packets to be held by queue
+//
+// @param queue Output parameter updated with handle of queue object
+//
+// @return bool true if successful, false otherwise
+//
+bool HsaRsrcFactory::CreateQueue(AgentInfo* agent_info, uint32_t num_pkts, hsa_queue_t** queue) {
+  hsa_status_t status;
+  status = hsa_queue_create(agent_info->dev_id, num_pkts, HSA_QUEUE_TYPE_MULTI, NULL, NULL,
+                            UINT32_MAX, UINT32_MAX, queue);
+  return (status == HSA_STATUS_SUCCESS);
+}
+
+// Create a Signal object and return its handle.
+//
+// @param value Initial value of signal object
+//
+// @param signal Output parameter updated with handle of signal object
+//
+// @return bool true if successful, false otherwise
+//
+bool HsaRsrcFactory::CreateSignal(uint32_t value, hsa_signal_t* signal) {
+  hsa_status_t status;
+  status = hsa_signal_create(value, 0, NULL, signal);
+  return (status == HSA_STATUS_SUCCESS);
+}
+
+// Allocate memory for use by a kernel of specified size in specified
+// agent's memory region. Currently supports Global segment whose Kernarg
+// flag set.
+//
+// @param agent_info Agent from whose memory region to allocate
+//
+// @param size Size of memory in terms of bytes
+//
+// @return uint8_t* Pointer to buffer, null if allocation fails.
+//
+uint8_t* HsaRsrcFactory::AllocateLocalMemory(const AgentInfo* agent_info, size_t size) {
+  hsa_status_t status;
+  uint8_t* buffer = NULL;
+  size = (size + MEM_PAGE_MASK) & ~MEM_PAGE_MASK;
+
+  if (agent_info->coarse_region.handle != 0) {
+    // Allocate in local memory if it is available
+    status = hsa_memory_allocate(agent_info->coarse_region, size, (void**)&buffer);
+    if (status == HSA_STATUS_SUCCESS) {
+      status = hsa_memory_assign_agent(buffer, agent_info->dev_id, HSA_ACCESS_PERMISSION_RW);
+    }
+  } else {
+    // Allocate in system memory if local memory is not available
+    status = hsa_memory_allocate(agent_info->kernarg_region, size, (void**)&buffer);
+  }
+
+  return (status == HSA_STATUS_SUCCESS) ? buffer : NULL;
+}
+
+// Allocate memory tp pass kernel parameters.
+//
+// @param agent_info Agent from whose memory region to allocate
+//
+// @param size Size of memory in terms of bytes
+//
+// @return uint8_t* Pointer to buffer, null if allocation fails.
+//
+uint8_t* HsaRsrcFactory::AllocateSysMemory(const AgentInfo* agent_info, size_t size) {
+  hsa_status_t status;
+  size = (size + MEM_PAGE_MASK) & ~MEM_PAGE_MASK;
+
+  uint8_t* buffer = NULL;
+  status = hsa_memory_allocate(agent_info->kernarg_region, size, (void**)&buffer);
+  return (status == HSA_STATUS_SUCCESS) ? buffer : NULL;
+}
+
+// Transfer data method
+bool HsaRsrcFactory::TransferData(void* dest_buff, void* src_buff, uint32_t length,
+                                  bool host_to_dev) {
+  hsa_status_t status;
+  status = hsa_memory_copy(dest_buff, src_buff, length);
+  return (status == HSA_STATUS_SUCCESS);
+}
+
+// Loads an Assembled Brig file and Finalizes it into Device Isa
+//
+// @param agent_info Gpu device for which to finalize
+//
+// @param brig_path File path of the Assembled Brig file
+//
+// @param kernel_name Name of the kernel to finalize
+//
+// @param code_desc Handle of finalized Code Descriptor that could
+// be used to submit for execution
+//
+// @return bool true if successful, false otherwise
+//
+bool HsaRsrcFactory::LoadAndFinalize(AgentInfo* agent_info, const char* brig_path,
+                                     char* kernel_name, hsa_executable_symbol_t* code_desc) {
+  // Finalize the Hsail object into code object
+  hsa_status_t status;
+  hsa_code_object_t code_object;
+
+  // Build the code object filename
+  std::string filename(brig_path);
+  std::clog << "Code object filename: " << filename << std::endl;
+
+  // Open the file containing code object
+  std::ifstream codeStream(filename.c_str(), std::ios::binary | std::ios::ate);
+  if (!codeStream) {
+    std::cerr << "Error: failed to load " << filename << std::endl;
+    assert(false);
+    return false;
+  }
+
+  // Allocate memory to read in code object from file
+  size_t size = std::string::size_type(codeStream.tellg());
+  char* codeBuff = (char*)AllocateSysMemory(agent_info, size);
+  if (!codeBuff) {
+    std::cerr << "Error: failed to allocate memory for code object." << std::endl;
+    assert(false);
+    return false;
+  }
+
+  // Read the code object into allocated memory
+  codeStream.seekg(0, std::ios::beg);
+  std::copy(std::istreambuf_iterator<char>(codeStream), std::istreambuf_iterator<char>(), codeBuff);
+
+  // De-Serialize the code object that has been read into memory
+  status = hsa_code_object_deserialize(codeBuff, size, NULL, &code_object);
+  if (status != HSA_STATUS_SUCCESS) {
+    std::cerr << "Failed to deserialize code object" << std::endl;
+    return false;
+  }
+
+  // Create executable.
+  hsa_executable_t hsaExecutable;
+  status =
+      hsa_executable_create(HSA_PROFILE_FULL, HSA_EXECUTABLE_STATE_UNFROZEN, "", &hsaExecutable);
+  CHECK_STATUS("Error in creating executable object", status);
+
+  // Load code object.
+  status = hsa_executable_load_code_object(hsaExecutable, agent_info->dev_id, code_object, "");
+  CHECK_STATUS("Error in loading executable object", status);
+
+  // Freeze executable.
+  status = hsa_executable_freeze(hsaExecutable, "");
+  CHECK_STATUS("Error in freezing executable object", status);
+
+  // Get symbol handle.
+  hsa_executable_symbol_t kernelSymbol;
+  status = hsa_executable_get_symbol(hsaExecutable, NULL, kernel_name, agent_info->dev_id, 0,
+                                     &kernelSymbol);
+  CHECK_STATUS("Error in looking up kernel symbol", status);
+
+  // Update output parameter
+  *code_desc = kernelSymbol;
+  return true;
+}
+
+// Add an instance of AgentInfo representing a Hsa Gpu agent
+void HsaRsrcFactory::AddAgentInfo(AgentInfo* agent_info, bool gpu) {
+  // Add input to Gpu list
+  if (gpu) {
+    gpu_list_.push_back(agent_info);
+    return;
+  }
+
+  // Add input to Cpu list
+  cpu_list_.push_back(agent_info);
+}
+
+// Print the various fields of Hsa Gpu Agents
+bool HsaRsrcFactory::PrintGpuAgents(const std::string& header) {
+  std::clog << header << " :" << std::endl;
+
+  AgentInfo* agent_info;
+  int size = uint32_t(gpu_list_.size());
+  for (int idx = 0; idx < size; idx++) {
+    agent_info = gpu_list_[idx];
+
+    std::clog << "> agent[" << idx << "] :" << std::endl;
+    std::clog << ">> Name : " << agent_info->name << std::endl;
+    std::clog << ">> Max Wave Size : " << agent_info->max_wave_size << std::endl;
+    std::clog << ">> Max Queue Size : " << agent_info->max_queue_size << std::endl;
+    std::clog << ">> Kernarg Region Id : " << agent_info->coarse_region.handle << std::endl;
+  }
+  return true;
+}
+
+HsaRsrcFactory* HsaRsrcFactory::instance_ = NULL;
+HsaRsrcFactory::mutex_t HsaRsrcFactory::mutex_;

projects/rocprofiler/test/util/hsa_rsrc_factory.h

@@ -0,0 +1,234 @@
+/**********************************************************************
+Copyright ©2013 Advanced Micro Devices, Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted
+provided that the following conditions are met:
+
+<95>    Redistributions of source code must retain the above copyright notice, this list of
+conditions and the following disclaimer.
+<95>    Redistributions in binary form must reproduce the above copyright notice, this list of
+conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+********************************************************************/
+
+#ifndef TEST_UTIL_HSA_RSRC_FACTORY_H_
+#define TEST_UTIL_HSA_RSRC_FACTORY_H_
+
+#include <hsa.h>
+#include <hsa_ext_finalize.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <iostream>
+#include <mutex>
+#include <string>
+#include <vector>
+
+#define HSA_ARGUMENT_ALIGN_BYTES 16
+#define HSA_QUEUE_ALIGN_BYTES 64
+#define HSA_PACKET_ALIGN_BYTES 64
+
+#define CHECK_STATUS(msg, status)                                                                  \
+  if (status != HSA_STATUS_SUCCESS) {                                                              \
+    const char* emsg = 0;                                                                          \
+    hsa_status_string(status, &emsg);                                                              \
+    printf("%s: %s\n", msg, emsg ? emsg : "<unknown error>");                                      \
+    exit(1);                                                                                       \
+  }
+
+static const unsigned MEM_PAGE_BYTES = 0x1000;
+static const unsigned MEM_PAGE_MASK = MEM_PAGE_BYTES - 1;
+
+// Encapsulates information about a Hsa Agent such as its
+// handle, name, max queue size, max wavefront size, etc.
+typedef struct {
+  // Handle of Agent
+  hsa_agent_t dev_id;
+
+  // Agent type - Cpu = 0, Gpu = 1 or Dsp = 2
+  uint32_t dev_type;
+
+  // Name of Agent whose length is less than 64
+  char name[64];
+
+  // Max size of Wavefront size
+  uint32_t max_wave_size;
+
+  // Max size of Queue buffer
+  uint32_t max_queue_size;
+
+  // Hsail profile supported by agent
+  hsa_profile_t profile;
+
+  // Memory region supporting kernel parameters
+  hsa_region_t coarse_region;
+
+  // Memory region supporting kernel arguments
+  hsa_region_t kernarg_region;
+
+} AgentInfo;
+
+class HsaRsrcFactory {
+ public:
+  typedef std::recursive_mutex mutex_t;
+
+  static HsaRsrcFactory* Create() {
+    std::lock_guard<mutex_t> lck(mutex_);
+    if (HsaRsrcFactory::instance_ == NULL) {
+      HsaRsrcFactory::instance_ = new HsaRsrcFactory();
+    }
+    return instance_;
+  }
+
+  static void Destroy() {
+    std::lock_guard<mutex_t> lck(mutex_);
+    if (instance_) delete instance_;
+    instance_ = NULL;
+  }
+
+  static HsaRsrcFactory& Instance() {
+    hsa_status_t status = (instance_ != NULL) ? HSA_STATUS_SUCCESS : HSA_STATUS_ERROR;
+    CHECK_STATUS("HsaRsrcFactory::Instance()", status);
+    return *instance_;
+  }
+
+  // Get the count of Hsa Gpu Agents available on the platform
+  //
+  // @return uint32_t Number of Gpu agents on platform
+  //
+  uint32_t GetCountOfGpuAgents();
+
+  // Get the count of Hsa Cpu Agents available on the platform
+  //
+  // @return uint32_t Number of Cpu agents on platform
+  //
+  uint32_t GetCountOfCpuAgents();
+
+  // Get the AgentInfo handle of a Gpu device
+  //
+  // @param idx Gpu Agent at specified index
+  //
+  // @param agent_info Output parameter updated with AgentInfo
+  //
+  // @return bool true if successful, false otherwise
+  //
+  bool GetGpuAgentInfo(uint32_t idx, AgentInfo** agent_info);
+
+  // Get the AgentInfo handle of a Cpu device
+  //
+  // @param idx Cpu Agent at specified index
+  //
+  // @param agent_info Output parameter updated with AgentInfo
+  //
+  // @return bool true if successful, false otherwise
+  //
+  bool GetCpuAgentInfo(uint32_t idx, AgentInfo** agent_info);
+
+  // Create a Queue object and return its handle. The queue object is expected
+  // to support user requested number of Aql dispatch packets.
+  //
+  // @param agent_info Gpu Agent on which to create a queue object
+  //
+  // @param num_Pkts Number of packets to be held by queue
+  //
+  // @param queue Output parameter updated with handle of queue object
+  //
+  // @return bool true if successful, false otherwise
+  //
+  bool CreateQueue(AgentInfo* agent_info, uint32_t num_pkts, hsa_queue_t** queue);
+
+  // Create a Signal object and return its handle.
+  //
+  // @param value Initial value of signal object
+  //
+  // @param signal Output parameter updated with handle of signal object
+  //
+  // @return bool true if successful, false otherwise
+  //
+  bool CreateSignal(uint32_t value, hsa_signal_t* signal);
+
+  // Allocate memory for use by a kernel of specified size in specified
+  // agent's memory region. Currently supports Global segment whose Kernarg
+  // flag set.
+  //
+  // @param agent_info Agent from whose memory region to allocate
+  //
+  // @param size Size of memory in terms of bytes
+  //
+  // @return uint8_t* Pointer to buffer, null if allocation fails.
+  //
+  uint8_t* AllocateLocalMemory(const AgentInfo* agent_info, size_t size);
+
+  // Allocate memory tp pass kernel parameters.
+  //
+  // @param agent_info Agent from whose memory region to allocate
+  //
+  // @param size Size of memory in terms of bytes
+  //
+  // @return uint8_t* Pointer to buffer, null if allocation fails.
+  //
+  uint8_t* AllocateSysMemory(const AgentInfo* agent_info, size_t size);
+
+  // Transfer data method
+  bool TransferData(void* dest_buff, void* src_buff, uint32_t length, bool host_to_dev);
+
+  // Loads an Assembled Brig file and Finalizes it into Device Isa
+  //
+  // @param agent_info Gpu device for which to finalize
+  //
+  // @param brig_path File path of the Assembled Brig file
+  //
+  // @param kernel_name Name of the kernel to finalize
+  //
+  // @param code_desc Handle of finalized Code Descriptor that could
+  // be used to submit for execution
+  //
+  // @return bool true if successful, false otherwise
+  //
+  bool LoadAndFinalize(AgentInfo* agent_info, const char* brig_path, char* kernel_name,
+                       hsa_executable_symbol_t* code_desc);
+
+  // Add an instance of AgentInfo representing a Hsa Gpu agent
+  void AddAgentInfo(AgentInfo* agent_info, bool gpu);
+
+  // Print the various fields of Hsa Gpu Agents
+  bool PrintGpuAgents(const std::string& header);
+
+ private:
+  // Constructor of the class. Will initialize the Hsa Runtime and
+  // query the system topology to get the list of Cpu and Gpu devices
+  HsaRsrcFactory();
+
+  // Destructor of the class
+  ~HsaRsrcFactory();
+
+  static HsaRsrcFactory* instance_;
+  static mutex_t mutex_;
+
+  // Used to maintain a list of Hsa Queue handles
+  std::vector<hsa_queue_t*> queue_list_;
+
+  // Used to maintain a list of Hsa Signal handles
+  std::vector<hsa_signal_t*> signal_list_;
+
+  // Used to maintain a list of Hsa Gpu Agent Info
+  std::vector<AgentInfo*> gpu_list_;
+
+  // Used to maintain a list of Hsa Cpu Agent Info
+  std::vector<AgentInfo*> cpu_list_;
+};
+
+#endif  // TEST_UTIL_HSA_RSRC_FACTORY_H_

projects/rocprofiler/test/util/perf_timer.cpp

@@ -0,0 +1,181 @@
+/**********************************************************************
+Copyright ©2013 Advanced Micro Devices, Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted
+provided that the following conditions are met:
+
+<95>    Redistributions of source code must retain the above copyright notice, this list of
+conditions and the following disclaimer.
+<95>    Redistributions in binary form must reproduce the above copyright notice, this list of
+conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+********************************************************************/
+
+#include "util/perf_timer.h"
+
+PerfTimer::PerfTimer() { freq_in_100mhz_ = MeasureTSCFreqHz(); }
+
+PerfTimer::~PerfTimer() {
+  while (!timers_.empty()) {
+    Timer* temp = timers_.back();
+    timers_.pop_back();
+    delete temp;
+  }
+}
+
+// New cretaed timer instantance index will be returned
+int PerfTimer::CreateTimer() {
+  Timer* newTimer = new Timer;
+  newTimer->start = 0;
+  newTimer->clocks = 0;
+
+#ifdef _WIN32
+  QueryPerformanceFrequency((LARGE_INTEGER*)&newTimer->freq);
+#else
+  newTimer->freq = (long long)1.0E3;
+#endif
+
+  /* Push back the address of new Timer instance created */
+  timers_.push_back(newTimer);
+  return (int)(timers_.size() - 1);
+}
+
+int PerfTimer::StartTimer(int index) {
+  if (index >= (int)timers_.size()) {
+    Error("Cannot reset timer. Invalid handle.");
+    return FAILURE;
+  }
+
+#ifdef _WIN32
+// General Windows timing method
+#ifndef _AMD
+  long long tmpStart;
+  QueryPerformanceCounter((LARGE_INTEGER*)&(tmpStart));
+  timers_[index]->start = (double)tmpStart;
+#else
+// AMD Windows timing method
+#endif
+#else
+// General Linux timing method
+#ifndef _AMD
+  struct timeval s;
+  gettimeofday(&s, 0);
+  timers_[index]->start = s.tv_sec * 1.0E3 + ((double)(s.tv_usec / 1.0E3));
+#else
+  // AMD timing method
+  unsigned int unused;
+  timers_[index]->start = __rdtscp(&unused);
+#endif
+#endif
+
+  return SUCCESS;
+}
+
+
+int PerfTimer::StopTimer(int index) {
+  double n = 0;
+  if (index >= (int)timers_.size()) {
+    Error("Cannot reset timer. Invalid handle.");
+    return FAILURE;
+  }
+#ifdef _WIN32
+#ifndef _AMD
+  long long n1;
+  QueryPerformanceCounter((LARGE_INTEGER*)&(n1));
+  n = (double)n1;
+#else
+// AMD Window Timing
+#endif
+
+#else
+// General Linux timing method
+#ifndef _AMD
+  struct timeval s;
+  gettimeofday(&s, 0);
+  n = s.tv_sec * 1.0E3 + (double)(s.tv_usec / 1.0E3);
+#else
+  // AMD Linux timing
+  unsigned int unused;
+  n = __rdtscp(&unused);
+#endif
+#endif
+
+  n -= timers_[index]->start;
+  timers_[index]->start = 0;
+
+#ifndef _AMD
+  timers_[index]->clocks += n;
+#else
+  // timers_[index]->clocks += 10 * n / freq_in_100mhz_; // unit is ns
+  timers_[index]->clocks += 1.0E-6 * 10 * n / freq_in_100mhz_;  // convert to ms
+#endif
+
+  return SUCCESS;
+}
+
+void PerfTimer::Error(std::string str) { std::cout << str << std::endl; }
+
+
+double PerfTimer::ReadTimer(int index) {
+  if (index >= (int)timers_.size()) {
+    Error("Cannot read timer. Invalid handle.");
+    return FAILURE;
+  }
+
+  double reading = double(timers_[index]->clocks);
+
+  reading = double(reading / timers_[index]->freq);
+
+  return reading;
+}
+
+
+uint64_t PerfTimer::CoarseTimestampUs() {
+#ifdef _WIN32
+  uint64_t freqHz, ticks;
+  QueryPerformanceFrequency((LARGE_INTEGER*)&freqHz);
+  QueryPerformanceCounter((LARGE_INTEGER*)&ticks);
+
+  // Scale numerator and divisor until (ticks * 1000000) fits in uint64_t.
+  while (ticks > (1ULL << 44)) {
+    ticks /= 16;
+    freqHz /= 16;
+  }
+
+  return (ticks * 1000000) / freqHz;
+#else
+  struct timespec ts;
+  clock_gettime(CLOCK_MONOTONIC_RAW, &ts);
+  return uint64_t(ts.tv_sec) * 1000000 + ts.tv_nsec / 1000;
+#endif
+}
+
+uint64_t PerfTimer::MeasureTSCFreqHz() {
+  // Make a coarse interval measurement of TSC ticks for 1 gigacycles.
+  unsigned int unused;
+  uint64_t tscTicksEnd;
+
+  uint64_t coarseBeginUs = CoarseTimestampUs();
+  uint64_t tscTicksBegin = __rdtscp(&unused);
+  do {
+    tscTicksEnd = __rdtscp(&unused);
+  } while (tscTicksEnd - tscTicksBegin < 1000000000);
+
+  uint64_t coarseEndUs = CoarseTimestampUs();
+
+  // Compute the TSC frequency and round to nearest 100MHz.
+  uint64_t coarseIntervalNs = (coarseEndUs - coarseBeginUs) * 1000;
+  uint64_t tscIntervalTicks = tscTicksEnd - tscTicksBegin;
+  return (tscIntervalTicks * 10 + (coarseIntervalNs / 2)) / coarseIntervalNs;
+}

projects/rocprofiler/test/util/perf_timer.h

@@ -0,0 +1,85 @@
+/**********************************************************************
+Copyright ©2013 Advanced Micro Devices, Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted
+provided that the following conditions are met:
+
+<95>    Redistributions of source code must retain the above copyright notice, this list of
+conditions and the following disclaimer.
+<95>    Redistributions in binary form must reproduce the above copyright notice, this list of
+conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+********************************************************************/
+
+#ifndef TEST_UTIL_PERF_TIMER_H_
+#define TEST_UTIL_PERF_TIMER_H_
+
+// Will use AMD timer or general Linux timer based on compilation flag
+// Need to consider platform is Windows or Linux
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#if defined(_MSC_VER)
+#include <intrin.h>
+#include <time.h>
+#include <windows.h>
+#else
+#if defined(__GNUC__)
+#include <sys/time.h>
+#include <x86intrin.h>
+#endif  // __GNUC__
+#endif  // _MSC_VER
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+class PerfTimer {
+ public:
+  enum { SUCCESS = 0, FAILURE = 1 };
+
+  PerfTimer();
+  ~PerfTimer();
+
+  // General Linux timing method
+  int CreateTimer();
+  int StartTimer(int index);
+  int StopTimer(int index);
+
+  // retrieve time
+  double ReadTimer(int index);
+  // write into a file
+  double WriteTimer(int index);
+
+ private:
+  struct Timer {
+    std::string name; /* name of time object */
+    long long freq;   /* frequency */
+    double clocks;    /* number of ticks at end */
+    double start;     /* start point ticks */
+  };
+
+  std::vector<Timer*> timers_; /* vector to Timer objects */
+  double freq_in_100mhz_;
+
+  // AMD timing method
+  uint64_t CoarseTimestampUs();
+  uint64_t MeasureTSCFreqHz();
+
+  void Error(std::string str);
+};
+
+#endif  // TEST_UTIL_PERF_TIMER_H_

projects/rocprofiler/test/util/test_assert.h

@@ -0,0 +1,52 @@
+/******************************************************************************
+
+Copyright ©2013 Advanced Micro Devices, Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*******************************************************************************/
+
+#ifndef TEST_CTRL_TEST_ASSERT_H_
+#define TEST_CTRL_TEST_ASSERT_H_
+
+#define TEST_ASSERT(cond)                                                                          \
+  {                                                                                                \
+    if (!(cond)) {                                                                                 \
+      std::cerr << "Assert failed(" << #cond << ") at " << __FILE__ << ", line " << __LINE__       \
+                << std::endl;                                                                      \
+      exit(-1);                                                                                    \
+    }                                                                                              \
+  }
+
+#define TEST_STATUS(cond)                                                                          \
+  {                                                                                                \
+    if (!(cond)) {                                                                                 \
+      std::cerr << "Test error at " << __FILE__ << ", line " << __LINE__                           \
+                << std::endl;                                                                      \
+      const char* message;                                                                         \
+      rocprofiler_error_string(&message);                                                          \
+      std::cerr << "ERROR: " << message << std::endl;                                              \
+      exit(-1);                                                                                    \
+    }                                                                                              \
+  }
+
+#endif  // TEST_CTRL_TEST_ASSERT_H_

projects/rocprofiler/test/util/xml.h

@@ -0,0 +1,221 @@
+#ifndef TEST_UTIL_XML_H_
+#define TEST_UTIL_XML_H_
+
+#include <fcntl.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <fstream>
+#include <iostream>
+#include <map>
+#include <vector>
+
+namespace xml {
+
+class Xml {
+  public:
+  typedef std::vector<char> token_t;
+  struct level_t {
+    std::string tag;
+    std::vector<level_t*> nodes;
+    std::map<std::string, std::string> opts;
+  };
+  typedef std::vector<level_t*> nodes_vec_t;
+
+  enum {
+    DECL_STATE,
+    BODY_STATE
+  };
+
+  Xml(const char* file_name) :
+    file_name_(file_name),
+    file_line_(0),
+    data_size_(0),
+    index_(0),
+    state_(BODY_STATE),
+    level_(NULL),
+    comment_(false)
+  {
+    AddLevel("top");
+
+    fd_ = open(file_name, O_RDONLY);
+    if (fd_ == -1) { 
+      std::cout << "XML file not found: " << file_name << std::endl;
+      return;
+    }
+
+    token_t remainder;
+    while (1) {
+      token_t token = (remainder.size()) ? remainder : NextToken();
+      remainder.clear();
+      // End of file
+      if (token.size() == 0) break;
+
+//      token_t token1 = token;
+//      token1.push_back('\0');
+//      std::cout << "> " << &token1[0] << std::endl;
+
+      switch(state_) {
+        case BODY_STATE:
+          if (token[0] == '<') {
+            bool node_begin = true;
+            unsigned ind = 1;
+            if (token[1] == '/') {
+              node_begin = false;
+              ++ind;
+            }
+
+            unsigned i = ind;
+            while (i < token.size()) { if (token[i] == '>') break; ++i; }
+            for (unsigned j = i + 1; j < token.size(); ++j) remainder.push_back(token[j]);
+
+            if (i == token.size()) {
+              if (node_begin) state_ = DECL_STATE;
+              else BadFormat(token);
+              token.push_back('\0');
+            } else token[i] = '\0';
+
+            const char* tag = strdup(&token[ind]);
+            if (node_begin) {
+              AddLevel(tag);
+            } else {
+              if (strncmp(CurrentLevel().c_str(), tag, strlen(tag))) {
+                token.back() = '>';
+                BadFormat(token);
+              }
+              UpLevel();
+            }
+          } else BadFormat(token);
+          break;
+        case DECL_STATE:
+          if (token[0] == '>') {
+            state_ = BODY_STATE;
+            for (unsigned j = 1; j < token.size(); ++j) remainder.push_back(token[j]);
+            continue;
+          } else {
+            token.push_back('\0');
+            unsigned j = 0;
+            for (j = 0; j < token.size(); ++j) if (token[j] == '=') break;
+            if (j == token.size()) BadFormat(token);
+            token[j] = '\0';
+            const char* key = &token[0];
+            const char* value = &token[j + 1];
+            AddOption(key, value);
+          }
+          break;
+        default:
+          std::cout << "Wrong state: " << state_ << std::endl;
+          exit(1);
+      }
+    }
+  }
+
+  std::vector<level_t*> GetNodes(std::string global_tag) {
+    return map_[global_tag];
+  }
+
+  void Print() const {
+    for(auto& elem : map_) {
+      for (auto node : elem.second) {
+        if (node->opts.size()) {
+          std::cout << elem.first << ":" << std::endl;
+          for (auto& opt : node->opts) {
+            std::cout << "  " << opt.first << " = " << opt.second << std::endl;
+          }
+        }
+      }
+    }
+  }
+
+  private:
+  bool LineEndCheck() {
+    bool found = false;
+    if (buffer_[index_] == '\n') {
+      buffer_[index_] = ' ';
+      ++file_line_;
+      found = true;
+      comment_ = false;
+    } else if (comment_ || (buffer_[index_] == '#')) {
+      found = true;
+      comment_ = true;
+    }
+    return found;
+  }
+
+  token_t NextToken() {
+    token_t token;
+
+    while (1) {
+      if (data_size_ == 0) {
+        data_size_ = read(fd_, buffer_, buf_size_);
+        if (data_size_ <= 0) break;
+      }
+      if (token.empty()) while ((index_ < data_size_) && ((buffer_[index_] == ' ') || LineEndCheck())) {
+        ++index_;
+      }
+      while ((index_ < data_size_) && (buffer_[index_] != ' ') && !LineEndCheck()) {
+        token.push_back(buffer_[index_++]);
+      }
+      if (index_ == data_size_) {
+        index_ = 0;
+        data_size_ = 0;
+      } else break;
+    }
+
+    return token;
+  }
+
+  void BadFormat(token_t token) {
+    token.push_back('\0');
+    std::cout << "Error: " << file_name_ << ", line " << file_line_ << ", bad XML token '" << &token[0] << "'" << std::endl;
+    exit(1);
+  }
+
+  void AddLevel(const std::string& tag) {
+    level_t* level = new level_t;
+    level->tag = tag;
+    if (level_) {
+      level_->nodes.push_back(level);
+      stack_.push_back(level_);
+    }
+    level_ = level;
+
+    std::string global_tag;
+    for (level_t* level : stack_) { global_tag += level->tag + "."; }
+    global_tag += tag;
+    map_[global_tag].push_back(level_);
+  }
+
+  void UpLevel() {
+    level_ = stack_.back();
+    stack_.pop_back();
+  }
+
+  std::string CurrentLevel() const {
+    return level_->tag;
+  }
+
+  void AddOption(const std::string& key, const std::string& value) {
+    level_->opts[key] = value;
+  }
+
+  const char* file_name_;
+  unsigned file_line_;
+  int fd_;
+  static const unsigned buf_size_ = 256;
+  char buffer_[buf_size_];
+  unsigned data_size_;
+  unsigned index_;
+  unsigned state_;
+  level_t* level_;
+  std::vector<level_t*> stack_;
+  std::map<std::string, nodes_vec_t> map_;
+  bool comment_;
+};
+
+}  // namespace xml
+
+#endif  // TEST_UTIL_XML_H_