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]
[ROCm/ROCR-Runtime commit: c494af9d49]
Dieser Commit ist enthalten in:
Besar Wicaksono (xN/A) TX [TEXT]
@@ -0,0 +1,7 @@
|
||||
OPENCL_DEPTH = ../../..
|
||||
|
||||
include $(OPENCL_DEPTH)/runtimenew/runtimedefs
|
||||
|
||||
SUBDIRS = build
|
||||
|
||||
include $(OPENCL_DEPTH)/runtimenew/runtimerules
|
||||
@@ -0,0 +1,8 @@
|
||||
OPENCL_DEPTH = ../../../..
|
||||
|
||||
include $(OPENCL_DEPTH)/hsadefs
|
||||
|
||||
BUILD_SUBDIRS = $(DEFAULT_TARGETS)
|
||||
BUILD_MAKEFILE = Makefile.get_info
|
||||
|
||||
include $(OPENCL_DEPTH)/hsarules
|
||||
@@ -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
|
||||
|
||||
@@ -0,0 +1,81 @@
|
||||
#include "get_info.h"
|
||||
|
||||
#include <iostream>
|
||||
|
||||
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;
|
||||
}
|
||||
@@ -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
|
||||
@@ -0,0 +1,267 @@
|
||||
#include "hsa_test.h"
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#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, "");
|
||||
}
|
||||
@@ -0,0 +1,80 @@
|
||||
#ifndef HSA_TEST_H
|
||||
#define HSA_TEST_H
|
||||
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#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<hsa_agent_t> cpus_;
|
||||
std::vector<hsa_agent_t> gpus_;
|
||||
|
||||
std::map<uint64_t, hsa_amd_memory_pool_t> global_fine_;
|
||||
std::map<uint64_t, hsa_amd_memory_pool_t> global_coarse_;
|
||||
std::map<uint64_t, hsa_amd_memory_pool_t> group_;
|
||||
};
|
||||
|
||||
#endif // HSA_TEST_H
|
||||
In neuem Issue referenzieren
Einen Benutzer sperren