From c494af9d49d0a3537ff0f1d51e26642bba8df1b3 Mon Sep 17 00:00:00 2001 From: "Besar Wicaksono (xN/A) TX [TEXT]" Date: Mon, 15 Feb 2016 18:11:44 -0500 Subject: [PATCH] Add sample application to use the new memory pool API. Details: - add HsaGetInfo program that prints out all available CPU, GPU and their respective memory pools. [git-p4: depot-paths = "//depot/stg/hsa/drivers/hsa/runtime/": change = 1237219] --- samples/GetInfo/Makefile | 7 + samples/GetInfo/build/Makefile | 8 + samples/GetInfo/build/Makefile.get_info | 107 ++++++++++ samples/GetInfo/get_info.cpp | 81 +++++++ samples/GetInfo/get_info.h | 14 ++ samples/common/hsa_test.cpp | 267 ++++++++++++++++++++++++ samples/common/hsa_test.h | 80 +++++++ 7 files changed, 564 insertions(+) create mode 100644 samples/GetInfo/Makefile create mode 100644 samples/GetInfo/build/Makefile create mode 100644 samples/GetInfo/build/Makefile.get_info create mode 100644 samples/GetInfo/get_info.cpp create mode 100644 samples/GetInfo/get_info.h create mode 100644 samples/common/hsa_test.cpp create mode 100644 samples/common/hsa_test.h diff --git a/samples/GetInfo/Makefile b/samples/GetInfo/Makefile new file mode 100644 index 0000000000..11141a08a8 --- /dev/null +++ b/samples/GetInfo/Makefile @@ -0,0 +1,7 @@ +OPENCL_DEPTH = ../../.. + +include $(OPENCL_DEPTH)/runtimenew/runtimedefs + +SUBDIRS = build + +include $(OPENCL_DEPTH)/runtimenew/runtimerules diff --git a/samples/GetInfo/build/Makefile b/samples/GetInfo/build/Makefile new file mode 100644 index 0000000000..26e7d28116 --- /dev/null +++ b/samples/GetInfo/build/Makefile @@ -0,0 +1,8 @@ +OPENCL_DEPTH = ../../../.. + +include $(OPENCL_DEPTH)/hsadefs + +BUILD_SUBDIRS = $(DEFAULT_TARGETS) +BUILD_MAKEFILE = Makefile.get_info + +include $(OPENCL_DEPTH)/hsarules diff --git a/samples/GetInfo/build/Makefile.get_info b/samples/GetInfo/build/Makefile.get_info new file mode 100644 index 0000000000..fb14b708b4 --- /dev/null +++ b/samples/GetInfo/build/Makefile.get_info @@ -0,0 +1,107 @@ +include $(OPENCL_DEPTH)/hsadefs + + +# Executable containing all the API core tests +EXE_TARGET = HsaGetInfo + +# +# Makefile construct to copy executable to Dist folder +# +DIST_BIN_TARGET = $(EXE_TARGET) +ifdef ATI_OS_WINDOWS + DIST_BIN_TARGETS = $(EXE_TARGET)$(EXE_EXT) +endif + +ifdef ATI_BITS_64 + LIB_SUFFIX=64 + BITS=64 + CMPILERBITS=64 +else + LIB_SUFFIX= + BITS= + ifdef ATI_OS_WINDOWS + CMPILERBITS= + else + CMPILERBITS=32 + endif +endif + +ifdef ATI_OS_WINDOWS + LFLAGS += /subsystem:console + CORE_LIB=dll + LIB_PREFIX= + DYN_LIB_EXT=$(LIB_EXT) + UTIL_EXT=win +else + LIB_PREFIX=lib + CORE_LIB=so + DYN_LIB_EXT=$(DLL_EXT) + UTIL_EXT= +endif + +LCXXDEFS += -DAMD_INTERNAL_BUILD + +vpath %.cpp $(COMPONENT_DEPTH) +CPPFILES := $(notdir $(wildcard $(COMPONENT_DEPTH)/*.cpp)) + +TOOLS_TEST_COMMON=$(COMPONENT_DEPTH)/../common +vpath %.cpp $(TOOLS_TEST_COMMON) +CPPFILES += $(notdir $(wildcard $(TOOLS_TEST_COMMON)/*.cpp)) + + +ifdef ATI_OS_LINUX + GCXXOPTS := $(filter-out -fno-rtti,$(GCXXOPTS)) + GCXXOPTS := $(filter-out -fno-exceptions,$(GCXXOPTS)) + LFLAGS += -L$(DIST_LIB_DEST) -lpthread $(LIBSTDCXX) -lm -ldl -lrt -lstdc++ + #LFLAGS += -L$(DIST_LIB_DEST) -lpthread $(LIBSTDCXX) -lm -ldl -lrt +endif + +SC_DIR_NAME ?= finalizer +export HT_DEPTH=$(OPENCL_DEPTH)/compiler/$(SC_DIR_NAME)/HSAIL/hsail-tools +include $(HT_DEPTH)/htlibs + +#LCINCS := $(INCSWITCH) "$(OPENCL_DEPTH)/contrib/gtest-1.6.0/include" +LCINCS += $(INCSWITCH) "$(OPENCL_DEPTH)/runtime" +LCINCS += $(INCSWITCH) "$(OPENCL_DEPTH)/runtime/samples" +LCINCS += $(INCSWITCH) "$(OPENCL_DEPTH)/contrib/elftoolchain/libelf" +LCINCS += $(INCSWITCH) "$(OPENCL_DEPTH)/contrib/elftoolchain/common" +LCINCS += $(INCSWITCH) "$(OPENCL_DEPTH)/runtime/inc" +LCINCS += $(LIBHSAIL_INCS) $(LIBHSAIL_AMD_INCS) + +LCINCS += $(INCSWITCH) "$(OPENCL_PATH)/compiler/lib/include" +LCINCS += $(INCSWITCH) "$(OPENCL_DEPTH)/runtime/samples/common" + +UTIL_BUILD=build/$(OS_TYPE)/util/$(UTIL_EXT)/$(BUILD_DIR) +#LLLIBS += $(OPENCL_DEPTH)/runtime/core/$(UTIL_BUILD)/util$(UTIL_EXT)$(LIB_EXT) + + +LIBELF_DIR=build/$(OS_TYPE)/$(BUILD_DIR) +RUNTIME_BUILD=build/$(OS_TYPE)/$(CORE_LIB)/$(BUILD_DIR) +ifdef ATI_OS_LINUX + GCXXOPTS := $(filter-out -fno-exceptions,$(GCXXOPTS)) + LFLAGS += -L$(DIST_LIB_DEST) -lpthread $(LIBSTDCXX) -lm -ldl -lrt + LFLAGS += -L$(OPENCL_DEPTH)/contrib/elftoolchain/libelf/$(LIBELF_DIR) -lelf + LFLAGS += -L$(OPENCL_DEPTH)/runtime/core/$(RUNTIME_BUILD) -lhsa-runtime$(LIB_SUFFIX) + LFLAGS += -L$(OPENCL_DEPTH)/runtime/tools/$(RUNTIME_BUILD) -lhsa-runtime-tools$(LIB_SUFFIX) +else + # Verify the extension of libelf is valid i.e. is not dll but instead is "lib" + #LLLIBS += -L$(OPENCL_DEPTH)/contrib/elftoolchain/libelf/$(LIBELF_DIR)/libelf + LLLIBS += $(OPENCL_DEPTH)/runtime/core/$(RUNTIME_BUILD)/hsa-runtime$(LIB_SUFFIX)$(LIB_EXT) + LLLIBS += $(OPENCL_DEPTH)/runtime/tools/$(RUNTIME_BUILD)/hsa-runtime-tools$(LIB_SUFFIX)$(LIB_EXT) +endif +LLLIBS += $(LIBHSAIL_USER_LIBS) + +# +# Copy the Hsa ample to Hsa distribution folder +# +ifdef ATI_OS_LINUX + LOCAL_TARGETS = inst_sample_copy +endif +inst_sample_copy: + $(MKDIR) $(DIST_BIN_DEST)/../../samples/$(OS_TYPE) + -$(RM) -f $(DIST_BIN_DEST)/../../samples/$(OS_TYPE)/$(EXE_TARGET) + $(CP) $(BUILD_DIR)/$(EXE_TARGET) $(DIST_BIN_DEST)/../../samples/$(OS_TYPE) + + +include $(OPENCL_DEPTH)/hsarules + diff --git a/samples/GetInfo/get_info.cpp b/samples/GetInfo/get_info.cpp new file mode 100644 index 0000000000..834416efca --- /dev/null +++ b/samples/GetInfo/get_info.cpp @@ -0,0 +1,81 @@ +#include "get_info.h" + +#include + +GetInfo::GetInfo() : HsaTest("HSA Info") {} + +GetInfo::~GetInfo() {} + +void GetInfo::Run() { + std::cout << std::endl; + std::cout << "Num CPUs in platform: " << cpus_.size() << std::endl; + std::cout << "------------------------------------------------\n"; + + for (size_t i = 0; i < cpus_.size(); ++i) { + hsa_agent_t cpu = cpus_[i]; + std::cout << "CPU[" << i << "] properties:" << std::endl; + std::cout << "------------------------------------------------\n"; + AgentProps prop(cpu); + PrintAgentInfo(prop); + std::cout << "------------------------------------------------\n"; + + hsa_amd_memory_pool_t global_fine = global_fine_[cpu.handle]; + if (global_fine.handle != 0) { + std::cout << "CPU[" << i << "] system fine grain pool properties:\n"; + std::cout << "------------------------------------------------\n"; + PoolProps prop(global_fine); + PrintPoolInfo(prop); + std::cout << "------------------------------------------------\n"; + } + + hsa_amd_memory_pool_t global_coarse = global_coarse_[cpu.handle]; + if (global_coarse.handle != 0) { + std::cout << "CPU[" << i << "] system coarse grain pool properties:\n"; + std::cout << "------------------------------------------------\n"; + PoolProps prop(global_coarse); + PrintPoolInfo(prop); + std::cout << "------------------------------------------------\n"; + } + } + + std::cout << std::endl; + std::cout << "Num GPUs in platform: " << gpus_.size() << std::endl; + std::cout << "------------------------------------------------\n"; + + for (size_t i = 0; i < gpus_.size(); ++i) { + hsa_agent_t gpu = gpus_[i]; + std::cout << "GPU[" << i << "] properties:" << std::endl; + std::cout << "------------------------------------------------\n"; + AgentProps prop(gpu); + PrintAgentInfo(prop); + std::cout << "------------------------------------------------\n"; + + hsa_amd_memory_pool_t global_coarse = global_coarse_[gpu.handle]; + if (global_coarse.handle != 0) { + std::cout << "GPU[" << i << "] local memory pool properties:\n"; + std::cout << "------------------------------------------------\n"; + PoolProps prop(global_coarse); + PrintPoolInfo(prop); + std::cout << "------------------------------------------------\n"; + } + + hsa_amd_memory_pool_t group = group_[gpu.handle]; + if (group.handle != 0) { + std::cout << "GPU[" << i << "] group memory pool properties:\n"; + std::cout << "------------------------------------------------\n"; + PoolProps prop(group); + PrintPoolInfo(prop); + std::cout << "------------------------------------------------\n"; + } + } +} + +int main(int argc, char* argv[]) { + GetInfo get_info; + + get_info.Init(); + get_info.Run(); + get_info.Cleanup(); + + return 0; +} \ No newline at end of file diff --git a/samples/GetInfo/get_info.h b/samples/GetInfo/get_info.h new file mode 100644 index 0000000000..1c20f7902e --- /dev/null +++ b/samples/GetInfo/get_info.h @@ -0,0 +1,14 @@ +#ifndef GET_INFO_H +#define GET_INFO_H + +#include "common/hsa_test.h" + +class GetInfo : public HsaTest { + public: + GetInfo(); + ~GetInfo(); + + void Run() override; +}; + +#endif // GET_INFO_H diff --git a/samples/common/hsa_test.cpp b/samples/common/hsa_test.cpp new file mode 100644 index 0000000000..bc7307b719 --- /dev/null +++ b/samples/common/hsa_test.cpp @@ -0,0 +1,267 @@ +#include "hsa_test.h" + +#include + +#define PRINT_ATTRIBUTE(attribute, value, metric) \ + std::cout << #attribute " = " << value << " " << metric << std::endl; + +static size_t ToMB(size_t size) { + return (size / (1024 * 1024)); +} + +HsaTest::HsaTest(const char* test_name) : test_name_(test_name) { + std::cout << "Running " << test_name_ << std::endl; + std::cout << "------------------------------------------------\n"; +} + +HsaTest::~HsaTest() {} + +void HsaTest::Init() { + hsa_status_t stat = hsa_init(); + if (stat != HSA_STATUS_SUCCESS) { + std::cerr << "hsa_init fail with status " << stat << std::endl; + } + + stat = hsa_iterate_agents(IterateAgents, (void*)this); +} + +void HsaTest::Cleanup() { hsa_shut_down(); } + +hsa_status_t HsaTest::IterateAgents(hsa_agent_t agent, void* data) { + HsaTest* hsatest = (HsaTest*)data; + + AgentProps prop(agent); + + if (prop.device_type == HSA_DEVICE_TYPE_CPU) { + hsatest->cpus_.push_back(agent); + } else if (prop.device_type == HSA_DEVICE_TYPE_GPU) { + hsatest->gpus_.push_back(agent); + } + + hsa_amd_memory_pool_t pools[3] = {{0}, {0}, {0}}; + hsa_status_t stat = + hsa_amd_agent_iterate_memory_pools(agent, IteratePools, pools); + + hsatest->global_fine_[agent.handle] = pools[0]; + hsatest->global_coarse_[agent.handle] = pools[1]; + hsatest->group_[agent.handle] = pools[2]; + + return HSA_STATUS_SUCCESS; +} + +hsa_status_t HsaTest::IteratePools(hsa_amd_memory_pool_t pool, void* data) { + hsa_amd_memory_pool_t* pools = (hsa_amd_memory_pool_t*)data; + + PoolProps prop(pool); + + if (prop.segment == HSA_AMD_SEGMENT_GLOBAL) { + if (prop.global_flag & HSA_AMD_MEMORY_POOL_GLOBAL_FLAG_FINE_GRAINED) { + pools[0].handle = pool.handle; + } else { + pools[1].handle = pool.handle; + } + } else if (prop.segment == HSA_AMD_SEGMENT_GROUP) { + pools[2].handle = pool.handle; + } + + return HSA_STATUS_SUCCESS; +} + +HsaTest::AgentProps::AgentProps(hsa_agent_t agent) { + if (agent.handle == 0) { + return; + } + + hsa_agent_get_info(agent, HSA_AGENT_INFO_NAME, (void*)name); + hsa_agent_get_info(agent, HSA_AGENT_INFO_VENDOR_NAME, (void*)vendor_name); + hsa_agent_get_info(agent, HSA_AGENT_INFO_FEATURE, (void*)&feature); + hsa_agent_get_info(agent, HSA_AGENT_INFO_MACHINE_MODEL, + (void*)&machine_model); + hsa_agent_get_info(agent, HSA_AGENT_INFO_PROFILE, (void*)&profile); + hsa_agent_get_info(agent, HSA_AGENT_INFO_DEFAULT_FLOAT_ROUNDING_MODE, + (void*)&default_float_rounding_mode); + hsa_agent_get_info(agent, + HSA_AGENT_INFO_BASE_PROFILE_DEFAULT_FLOAT_ROUNDING_MODES, + (void*)&base_profile_float_rounding_mode); + hsa_agent_get_info(agent, HSA_AGENT_INFO_FAST_F16_OPERATION, + (void*)&fast_f16_operation); + hsa_agent_get_info(agent, HSA_AGENT_INFO_WAVEFRONT_SIZE, + (void*)&wavefront_size); + hsa_agent_get_info(agent, HSA_AGENT_INFO_WORKGROUP_MAX_DIM, + (void*)workgroup_max_dim); + hsa_agent_get_info(agent, HSA_AGENT_INFO_WORKGROUP_MAX_SIZE, + (void*)&workgroup_max_size); + hsa_agent_get_info(agent, HSA_AGENT_INFO_GRID_MAX_DIM, (void*)&grid_max_dim); + hsa_agent_get_info(agent, HSA_AGENT_INFO_GRID_MAX_SIZE, + (void*)&grid_max_size); + hsa_agent_get_info(agent, HSA_AGENT_INFO_FBARRIER_MAX_SIZE, + (void*)&fbarrier_max_size); + hsa_agent_get_info(agent, HSA_AGENT_INFO_QUEUES_MAX, (void*)&queue_max); + hsa_agent_get_info(agent, HSA_AGENT_INFO_QUEUE_MIN_SIZE, + (void*)&queue_min_size); + hsa_agent_get_info(agent, HSA_AGENT_INFO_QUEUE_MAX_SIZE, + (void*)&queue_max_size); + hsa_agent_get_info(agent, HSA_AGENT_INFO_QUEUE_TYPE, (void*)&queue_type); + hsa_agent_get_info(agent, HSA_AGENT_INFO_NODE, (void*)&node); + hsa_agent_get_info(agent, HSA_AGENT_INFO_DEVICE, (void*)&device_type); + hsa_agent_get_info(agent, HSA_AGENT_INFO_CACHE_SIZE, (void*)cache_size); + hsa_agent_get_info(agent, HSA_AGENT_INFO_ISA, (void*)&isa); + hsa_agent_get_info(agent, HSA_AGENT_INFO_EXTENSIONS, (void*)extensions); + hsa_agent_get_info(agent, HSA_AGENT_INFO_VERSION_MAJOR, + (void*)&version_major); + hsa_agent_get_info(agent, HSA_AGENT_INFO_VERSION_MINOR, + (void*)&version_minor); +} + +HsaTest::PoolProps::PoolProps(hsa_amd_memory_pool_t pool) { + if (pool.handle == 0) { + return; + } + + hsa_amd_memory_pool_get_info(pool, HSA_AMD_MEMORY_POOL_INFO_SEGMENT, + (void*)&segment); + hsa_amd_memory_pool_get_info(pool, HSA_AMD_MEMORY_POOL_INFO_GLOBAL_FLAGS, + (void*)&global_flag); + hsa_amd_memory_pool_get_info(pool, HSA_AMD_MEMORY_POOL_INFO_SIZE, + (void*)&size); + hsa_amd_memory_pool_get_info(pool, + HSA_AMD_MEMORY_POOL_INFO_RUNTIME_ALLOC_ALLOWED, + (void*)&alloc_allowed); + hsa_amd_memory_pool_get_info(pool, + HSA_AMD_MEMORY_POOL_INFO_RUNTIME_ALLOC_GRANULE, + (void*)&alloc_granule); + hsa_amd_memory_pool_get_info(pool, + HSA_AMD_MEMORY_POOL_INFO_RUNTIME_ALLOC_ALIGNMENT, + (void*)&alloc_alignment); + hsa_amd_memory_pool_get_info(pool, HSA_AMD_MEMORY_POOL_INFO_ACCESSIBLE_BY_ALL, + (void*)&all_accessible); +} + +void HsaTest::PrintAgentInfo(AgentProps& prop) { + PRINT_ATTRIBUTE(HSA_AGENT_INFO_NAME, prop.name, ""); + + PRINT_ATTRIBUTE(HSA_AGENT_INFO_VENDOR_NAME, prop.vendor_name, ""); + + const char* feature_strings[] = {"NONE", "HSA_AGENT_FEATURE_DISPATCH", + "HSA_AGENT_FEATURE_AGENT_DISPATCH"}; + PRINT_ATTRIBUTE(HSA_AGENT_INFO_FEATURE, feature_strings[prop.feature], ""); + + const char* model_strings[] = {"HSA_MACHINE_MODEL_SMALL", + "HSA_MACHINE_MODEL_LARGE"}; + PRINT_ATTRIBUTE(HSA_AGENT_INFO_MACHINE_MODEL, + model_strings[prop.machine_model], ""); + + const char* profile_strings[] = {"HSA_PROFILE_BASE", "HSA_PROFILE_FULL"}; + PRINT_ATTRIBUTE(HSA_AGENT_INFO_PROFILE, profile_strings[prop.profile], ""); + + const char* default_float_rounding_strings[] = { + "HSA_DEFAULT_FLOAT_ROUNDING_MODE_DEFAULT", + "HSA_DEFAULT_FLOAT_ROUNDING_MODE_ZERO", + "HSA_DEFAULT_FLOAT_ROUNDING_MODE_NEAR"}; + PRINT_ATTRIBUTE( + HSA_AGENT_INFO_DEFAULT_FLOAT_ROUNDING_MODE, + default_float_rounding_strings[prop.default_float_rounding_mode], ""); + PRINT_ATTRIBUTE( + HSA_AGENT_INFO_BASE_PROFILE_DEFAULT_FLOAT_ROUNDING_MODES, + default_float_rounding_strings[prop.base_profile_float_rounding_mode], + ""); + + PRINT_ATTRIBUTE(HSA_AGENT_INFO_FAST_F16_OPERATION, prop.fast_f16_operation, + ""); + + PRINT_ATTRIBUTE(HSA_AGENT_INFO_WAVEFRONT_SIZE, prop.wavefront_size, ""); + + PRINT_ATTRIBUTE(HSA_AGENT_INFO_WORKGROUP_MAX_DIM[0], + prop.workgroup_max_dim[0], ""); + PRINT_ATTRIBUTE(HSA_AGENT_INFO_WORKGROUP_MAX_DIM[1], + prop.workgroup_max_dim[1], ""); + PRINT_ATTRIBUTE(HSA_AGENT_INFO_WORKGROUP_MAX_DIM[2], + prop.workgroup_max_dim[2], ""); + + PRINT_ATTRIBUTE(HSA_AGENT_INFO_WORKGROUP_MAX_SIZE, prop.workgroup_max_size, + ""); + + PRINT_ATTRIBUTE(HSA_AGENT_INFO_GRID_MAX_DIM.x, prop.grid_max_dim.x, ""); + PRINT_ATTRIBUTE(HSA_AGENT_INFO_GRID_MAX_DIM.y, prop.grid_max_dim.y, ""); + PRINT_ATTRIBUTE(HSA_AGENT_INFO_GRID_MAX_DIM.z, prop.grid_max_dim.z, ""); + + PRINT_ATTRIBUTE(HSA_AGENT_INFO_GRID_MAX_SIZE, prop.grid_max_size, ""); + + PRINT_ATTRIBUTE(HSA_AGENT_INFO_FBARRIER_MAX_SIZE, prop.fbarrier_max_size, ""); + + PRINT_ATTRIBUTE(HSA_AGENT_INFO_QUEUES_MAX, prop.queue_max, ""); + + PRINT_ATTRIBUTE(HSA_AGENT_INFO_QUEUE_MIN_SIZE, prop.queue_min_size, ""); + + PRINT_ATTRIBUTE(HSA_AGENT_INFO_QUEUE_MAX_SIZE, prop.queue_max_size, ""); + + const char* queue_type_strings[] = {"HSA_QUEUE_TYPE_MULTI", + "HSA_QUEUE_TYPE_SINGLE"}; + PRINT_ATTRIBUTE(HSA_AGENT_INFO_QUEUE_TYPE, + queue_type_strings[prop.queue_type], ""); + + PRINT_ATTRIBUTE(HSA_AGENT_INFO_NODE, prop.node, ""); + + const char* device_type_strings[] = { + "HSA_DEVICE_TYPE_CPU", "HSA_DEVICE_TYPE_GPU", "HSA_DEVICE_TYPE_DSP"}; + PRINT_ATTRIBUTE(HSA_AGENT_INFO_DEVICE, device_type_strings[prop.device_type], + ""); + + PRINT_ATTRIBUTE(HSA_AGENT_INFO_CACHE_SIZE[0], prop.cache_size[0], "bytes"); + PRINT_ATTRIBUTE(HSA_AGENT_INFO_CACHE_SIZE[1], prop.cache_size[1], "bytes"); + PRINT_ATTRIBUTE(HSA_AGENT_INFO_CACHE_SIZE[2], prop.cache_size[2], "bytes"); + PRINT_ATTRIBUTE(HSA_AGENT_INFO_CACHE_SIZE[3], prop.cache_size[3], "bytes"); + + std::string extensions = ""; + extensions += (prop.extensions[HSA_EXTENSION_FINALIZER]) + ? "HSA_EXTENSION_FINALIZER | " + : ""; + extensions += + (prop.extensions[HSA_EXTENSION_IMAGES]) ? "HSA_EXTENSION_IMAGES | " : ""; + extensions += (prop.extensions[HSA_EXTENSION_AMD_PROFILER]) + ? "HSA_EXTENSION_AMD_PROFILER " + : ""; + PRINT_ATTRIBUTE(HSA_AGENT_INFO_EXTENSIONS, extensions, ""); + + PRINT_ATTRIBUTE(HSA_AGENT_INFO_VERSION_MAJOR, prop.version_major, ""); + PRINT_ATTRIBUTE(HSA_AGENT_INFO_VERSION_MINOR, prop.version_minor, ""); +} + +void HsaTest::PrintPoolInfo(PoolProps& prop) { + const char* segment_strings[] = { + "HSA_SEGMENT_GLOBAL", "HSA_AMD_SEGMENT_READONLY", + "HSA_AMD_SEGMENT_PRIVATE", "HSA_AMD_SEGMENT_GROUP"}; + PRINT_ATTRIBUTE(HSA_AMD_MEMORY_POOL_INFO_SEGMENT, + segment_strings[prop.segment], ""); + + std::string global_flag = ""; + global_flag += + (prop.global_flag & HSA_AMD_MEMORY_POOL_GLOBAL_FLAG_KERNARG_INIT) + ? "HSA_AMD_MEMORY_POOL_GLOBAL_FLAG_KERNARG_INIT | " + : ""; + global_flag += + (prop.global_flag & HSA_AMD_MEMORY_POOL_GLOBAL_FLAG_FINE_GRAINED) + ? "HSA_AMD_MEMORY_POOL_GLOBAL_FLAG_FINE_GRAINED | " + : ""; + global_flag += + (prop.global_flag & HSA_AMD_MEMORY_POOL_GLOBAL_FLAG_COARSE_GRAINED) + ? "HSA_AMD_MEMORY_POOL_GLOBAL_FLAG_COARSE_GRAINED " + : ""; + PRINT_ATTRIBUTE(HSA_AMD_MEMORY_POOL_INFO_GLOBAL_FLAGS, global_flag, ""); + + static const size_t kMb = 1024 * 1024; + if (prop.size >= kMb) { + PRINT_ATTRIBUTE(HSA_AMD_MEMORY_POOL_INFO_SIZE, ToMB(prop.size), "MB"); + } else { + PRINT_ATTRIBUTE(HSA_AMD_MEMORY_POOL_INFO_SIZE, prop.size, "bytes"); + } + + PRINT_ATTRIBUTE(HSA_AMD_MEMORY_POOL_INFO_RUNTIME_ALLOC_ALLOWED, + prop.alloc_allowed, ""); + PRINT_ATTRIBUTE(HSA_AMD_MEMORY_POOL_INFO_RUNTIME_ALLOC_GRANULE, + prop.alloc_granule, "bytes"); + PRINT_ATTRIBUTE(HSA_AMD_MEMORY_POOL_INFO_RUNTIME_ALLOC_ALIGNMENT, + prop.alloc_alignment, "bytes"); + PRINT_ATTRIBUTE(HSA_AMD_MEMORY_POOL_INFO_ACCESSIBLE_BY_ALL, + prop.all_accessible, ""); +} diff --git a/samples/common/hsa_test.h b/samples/common/hsa_test.h new file mode 100644 index 0000000000..7d8edd3ba3 --- /dev/null +++ b/samples/common/hsa_test.h @@ -0,0 +1,80 @@ +#ifndef HSA_TEST_H +#define HSA_TEST_H + +#include +#include +#include + +#include "hsa.h" +#include "hsa_ext_amd.h" + +class HsaTest { + public: + HsaTest(const char* test_name); + virtual ~HsaTest(); + + void Init(); + void Cleanup(); + + virtual void Run() = 0; + + protected: + static hsa_status_t IterateAgents(hsa_agent_t agent, void* data); + static hsa_status_t IteratePools(hsa_amd_memory_pool_t pool, void* data); + + typedef struct AgentProps { + AgentProps(hsa_agent_t); + + char name[64]; + char vendor_name[64]; + hsa_agent_feature_t feature; + hsa_machine_model_t machine_model; + hsa_profile_t profile; + hsa_default_float_rounding_mode_t default_float_rounding_mode; + hsa_default_float_rounding_mode_t base_profile_float_rounding_mode; + bool fast_f16_operation; + uint32_t wavefront_size; + uint16_t workgroup_max_dim[3]; + uint32_t workgroup_max_size; + hsa_dim3_t grid_max_dim; + uint32_t grid_max_size; + uint32_t fbarrier_max_size; + uint32_t queue_max; + uint32_t queue_min_size; + uint32_t queue_max_size; + hsa_queue_type_t queue_type; + uint32_t node; + hsa_device_type_t device_type; + uint32_t cache_size[4]; + hsa_isa_t isa; + uint8_t extensions[128]; + uint16_t version_major; + uint16_t version_minor; + } AgentProps; + + typedef struct PoolProps { + PoolProps(hsa_amd_memory_pool_t pool); + + hsa_amd_segment_t segment; + hsa_amd_memory_pool_global_flag_t global_flag; + size_t size; + bool alloc_allowed; + size_t alloc_granule; + size_t alloc_alignment; + bool all_accessible; + } PoolProps; + + virtual void PrintAgentInfo(AgentProps& prop); + virtual void PrintPoolInfo(PoolProps& prop); + + std::string test_name_; + + std::vector cpus_; + std::vector gpus_; + + std::map global_fine_; + std::map global_coarse_; + std::map group_; +}; + +#endif // HSA_TEST_H