Update code object/isa/loader to hsa v1.1
- Includes Sean's latest changes
- Cleanups/improvements
- Fixes for few bugs that crept over from previous releases
Change-Id: I839dc4895bf13ebd0afc8843424387a9fef667b0
[ROCm/ROCR-Runtime commit: c2c993e0d8]
Cette révision appartient à :
Konstantin Zhuravlyov
@@ -57,6 +57,7 @@ add_definitions ( -D__AMD64__ )
|
||||
add_definitions ( -D__x86_64__ )
|
||||
add_definitions ( -DAMD_INTERNAL_BUILD )
|
||||
add_definitions ( -DLITTLEENDIAN_CPU=1 )
|
||||
add_definitions ( -D HSA_DEPRECATED= )
|
||||
|
||||
## Set ext runtime module name and project name.
|
||||
set ( FINALIZE_NAME "hsa-ext-finalize" )
|
||||
|
||||
@@ -56,6 +56,7 @@ add_definitions ( -D__AMD64__ )
|
||||
add_definitions ( -D__x86_64__ )
|
||||
add_definitions ( -DAMD_INTERNAL_BUILD )
|
||||
add_definitions ( -DLITTLEENDIAN_CPU=1 )
|
||||
add_definitions ( -D HSA_DEPRECATED= )
|
||||
|
||||
## Set ext runtime module name and project name.
|
||||
set ( IMAGE_NAME "hsa-ext-image" )
|
||||
|
||||
@@ -38,6 +38,7 @@ add_definitions ( -D__AMD64__ )
|
||||
add_definitions ( -D__x86_64__ )
|
||||
add_definitions ( -DAMD_INTERNAL_BUILD )
|
||||
add_definitions ( -DLITTLEENDIAN_CPU=1 )
|
||||
add_definitions ( -D HSA_DEPRECATED= )
|
||||
|
||||
## Set ext runtime module name and project name.
|
||||
set ( TOOLS_NAME "hsa-runtime-tools" )
|
||||
|
||||
@@ -46,6 +46,8 @@ project(hsa-runtime)
|
||||
|
||||
list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake_modules")
|
||||
|
||||
add_definitions (-D HSA_DEPRECATED=)
|
||||
|
||||
include(utils)
|
||||
include(hsa_common)
|
||||
|
||||
|
||||
@@ -100,11 +100,13 @@ endif ()
|
||||
|
||||
|
||||
## ------------------------- Linux Compiler and Linker options -------------------------
|
||||
set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -fexceptions -fno-rtti -fvisibility=hidden -Wno-error=sign-compare -Wno-sign-compare -Wno-write-strings -Wno-deprecated-declarations -Wno-conversion-null -fno-math-errno -fno-threadsafe-statics -fmerge-all-constants -fms-extensions -Wno-error=comment -Wno-comment -Wno-error=pointer-arith -Wno-pointer-arith -Wno-error=unused-variable -Wno-error=unused-but-set-variable -Wno-error=unused-function" )
|
||||
set ( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -fexceptions -fno-rtti -fvisibility=hidden -Wno-error=sign-compare -Wno-sign-compare -Wno-write-strings -Wno-conversion-null -fno-math-errno -fno-threadsafe-statics -fmerge-all-constants -fms-extensions -Wno-error=comment -Wno-comment -Wno-error=pointer-arith -Wno-pointer-arith -Wno-error=unused-variable -Wno-error=unused-but-set-variable -Wno-error=unused-function" )
|
||||
|
||||
set ( DRVDEF "${CMAKE_CURRENT_SOURCE_DIR}/hsacore.so.def" )
|
||||
|
||||
set ( CMAKE_SHARED_LINKER_FLAGS "-Wl,-Bdynamic -Wl,-z,noexecstack -Wl,--version-script=${DRVDEF}" )
|
||||
set ( LNKSCR "${CMAKE_CURRENT_SOURCE_DIR}/hsacore.so.link" )
|
||||
|
||||
set ( CMAKE_SHARED_LINKER_FLAGS "-Wl,-Bdynamic -Wl,-z,noexecstack -Wl,${LNKSCR} -Wl,--version-script=${DRVDEF}" )
|
||||
|
||||
set ( CMAKE_SKIP_BUILD_RPATH TRUE)
|
||||
|
||||
@@ -133,6 +135,7 @@ set ( CORE_SRCS ${CORE_SRCS} runtime/interrupt_signal.cpp )
|
||||
set ( CORE_SRCS ${CORE_SRCS} runtime/isa.cpp )
|
||||
set ( CORE_SRCS ${CORE_SRCS} runtime/runtime.cpp )
|
||||
set ( CORE_SRCS ${CORE_SRCS} runtime/signal.cpp )
|
||||
set ( CORE_SRCS ${CORE_SRCS} runtime/cache.cpp )
|
||||
set ( CORE_SRCS ${CORE_SRCS} common/shared.cpp )
|
||||
set ( CORE_SRCS ${CORE_SRCS} common/hsa_table_interface.cpp )
|
||||
|
||||
|
||||
+395
-158
@@ -67,6 +67,11 @@ hsa_status_t HSA_API
|
||||
return coreApiTable->hsa_system_get_info_fn(attribute, value);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API hsa_extension_get_name(uint16_t extension, const char** name)
|
||||
{
|
||||
return coreApiTable->hsa_extension_get_name_fn(extension, name);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API
|
||||
hsa_system_extension_supported(uint16_t extension, uint16_t version_major,
|
||||
uint16_t version_minor, bool* result) {
|
||||
@@ -74,6 +79,13 @@ hsa_status_t HSA_API
|
||||
extension, version_major, version_minor, result);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API
|
||||
hsa_system_major_extension_supported(uint16_t extension, uint16_t version_major,
|
||||
uint16_t *version_minor, bool* result) {
|
||||
return coreApiTable->hsa_system_major_extension_supported_fn(
|
||||
extension, version_major, version_minor, result);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API
|
||||
hsa_system_get_extension_table(uint16_t extension, uint16_t version_major,
|
||||
uint16_t version_minor, void* table) {
|
||||
@@ -81,6 +93,11 @@ hsa_status_t HSA_API
|
||||
extension, version_major, version_minor, table);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API hsa_system_get_major_extension_table(uint16_t extension, uint16_t version_major, size_t table_length, void *table)
|
||||
{
|
||||
return coreApiTable->hsa_system_get_major_extension_table_fn(extension, version_major, table_length, table);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API
|
||||
hsa_iterate_agents(hsa_status_t (*callback)(hsa_agent_t agent, void* data),
|
||||
void* data) {
|
||||
@@ -99,6 +116,16 @@ hsa_status_t HSA_API hsa_agent_get_exception_policies(hsa_agent_t agent,
|
||||
return coreApiTable->hsa_agent_get_exception_policies_fn(agent, profile, mask);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API hsa_cache_get_info(hsa_cache_t cache, hsa_cache_info_t attribute, void *value)
|
||||
{
|
||||
return coreApiTable->hsa_cache_get_info_fn(cache, attribute, value);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API hsa_agent_iterate_caches(hsa_agent_t agent, hsa_status_t (*callback )(hsa_cache_t cache, void *data), void *value)
|
||||
{
|
||||
return coreApiTable->hsa_agent_iterate_caches_fn(agent, callback, value);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API
|
||||
hsa_agent_extension_supported(uint16_t extension, hsa_agent_t agent,
|
||||
uint16_t version_major,
|
||||
@@ -107,6 +134,11 @@ hsa_status_t HSA_API
|
||||
extension, agent, version_major, version_minor, result);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API hsa_agent_major_extension_supported(uint16_t extension, hsa_agent_t agent, uint16_t version_major, uint16_t *version_minor, bool *result)
|
||||
{
|
||||
return coreApiTable->hsa_agent_major_extension_supported_fn(extension, agent, version_major, version_minor, result);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API
|
||||
hsa_queue_create(hsa_agent_t agent, uint32_t size, hsa_queue_type_t type,
|
||||
void (*callback)(hsa_status_t status, hsa_queue_t* source,
|
||||
@@ -134,16 +166,16 @@ hsa_status_t HSA_API hsa_queue_inactivate(hsa_queue_t* queue) {
|
||||
return coreApiTable->hsa_queue_inactivate_fn(queue);
|
||||
}
|
||||
|
||||
uint64_t HSA_API hsa_queue_load_read_index_acquire(const hsa_queue_t* queue) {
|
||||
return coreApiTable->hsa_queue_load_read_index_acquire_fn(queue);
|
||||
uint64_t HSA_API hsa_queue_load_read_index_scacquire(const hsa_queue_t* queue) {
|
||||
return coreApiTable->hsa_queue_load_read_index_scacquire_fn(queue);
|
||||
}
|
||||
|
||||
uint64_t HSA_API hsa_queue_load_read_index_relaxed(const hsa_queue_t* queue) {
|
||||
return coreApiTable->hsa_queue_load_read_index_relaxed_fn(queue);
|
||||
}
|
||||
|
||||
uint64_t HSA_API hsa_queue_load_write_index_acquire(const hsa_queue_t* queue) {
|
||||
return coreApiTable->hsa_queue_load_write_index_acquire_fn(queue);
|
||||
uint64_t HSA_API hsa_queue_load_write_index_scacquire(const hsa_queue_t* queue) {
|
||||
return coreApiTable->hsa_queue_load_write_index_scacquire_fn(queue);
|
||||
}
|
||||
|
||||
uint64_t HSA_API hsa_queue_load_write_index_relaxed(const hsa_queue_t* queue) {
|
||||
@@ -155,22 +187,22 @@ void HSA_API hsa_queue_store_write_index_relaxed(const hsa_queue_t* queue,
|
||||
return coreApiTable->hsa_queue_store_write_index_relaxed_fn(queue, value);
|
||||
}
|
||||
|
||||
void HSA_API hsa_queue_store_write_index_release(const hsa_queue_t* queue,
|
||||
void HSA_API hsa_queue_store_write_index_screlease(const hsa_queue_t* queue,
|
||||
uint64_t value) {
|
||||
return coreApiTable->hsa_queue_store_write_index_release_fn(queue, value);
|
||||
return coreApiTable->hsa_queue_store_write_index_screlease_fn(queue, value);
|
||||
}
|
||||
|
||||
uint64_t HSA_API hsa_queue_cas_write_index_acq_rel(const hsa_queue_t* queue,
|
||||
uint64_t HSA_API hsa_queue_cas_write_index_scacq_screl(const hsa_queue_t* queue,
|
||||
uint64_t expected,
|
||||
uint64_t value) {
|
||||
return coreApiTable->hsa_queue_cas_write_index_acq_rel_fn(queue, expected,
|
||||
return coreApiTable->hsa_queue_cas_write_index_scacq_screl_fn(queue, expected,
|
||||
value);
|
||||
}
|
||||
|
||||
uint64_t HSA_API hsa_queue_cas_write_index_acquire(const hsa_queue_t* queue,
|
||||
uint64_t HSA_API hsa_queue_cas_write_index_scacquire(const hsa_queue_t* queue,
|
||||
uint64_t expected,
|
||||
uint64_t value) {
|
||||
return coreApiTable->hsa_queue_cas_write_index_acquire_fn(queue, expected,
|
||||
return coreApiTable->hsa_queue_cas_write_index_scacquire_fn(queue, expected,
|
||||
value);
|
||||
}
|
||||
|
||||
@@ -181,21 +213,21 @@ uint64_t HSA_API hsa_queue_cas_write_index_relaxed(const hsa_queue_t* queue,
|
||||
value);
|
||||
}
|
||||
|
||||
uint64_t HSA_API hsa_queue_cas_write_index_release(const hsa_queue_t* queue,
|
||||
uint64_t HSA_API hsa_queue_cas_write_index_screlease(const hsa_queue_t* queue,
|
||||
uint64_t expected,
|
||||
uint64_t value) {
|
||||
return coreApiTable->hsa_queue_cas_write_index_release_fn(queue, expected,
|
||||
return coreApiTable->hsa_queue_cas_write_index_screlease_fn(queue, expected,
|
||||
value);
|
||||
}
|
||||
|
||||
uint64_t HSA_API hsa_queue_add_write_index_acq_rel(const hsa_queue_t* queue,
|
||||
uint64_t HSA_API hsa_queue_add_write_index_scacq_screl(const hsa_queue_t* queue,
|
||||
uint64_t value) {
|
||||
return coreApiTable->hsa_queue_add_write_index_acq_rel_fn(queue, value);
|
||||
return coreApiTable->hsa_queue_add_write_index_scacq_screl_fn(queue, value);
|
||||
}
|
||||
|
||||
uint64_t HSA_API hsa_queue_add_write_index_acquire(const hsa_queue_t* queue,
|
||||
uint64_t HSA_API hsa_queue_add_write_index_scacquire(const hsa_queue_t* queue,
|
||||
uint64_t value) {
|
||||
return coreApiTable->hsa_queue_add_write_index_acquire_fn(queue, value);
|
||||
return coreApiTable->hsa_queue_add_write_index_scacquire_fn(queue, value);
|
||||
}
|
||||
|
||||
uint64_t HSA_API hsa_queue_add_write_index_relaxed(const hsa_queue_t* queue,
|
||||
@@ -203,9 +235,9 @@ uint64_t HSA_API hsa_queue_add_write_index_relaxed(const hsa_queue_t* queue,
|
||||
return coreApiTable->hsa_queue_add_write_index_relaxed_fn(queue, value);
|
||||
}
|
||||
|
||||
uint64_t HSA_API hsa_queue_add_write_index_release(const hsa_queue_t* queue,
|
||||
uint64_t HSA_API hsa_queue_add_write_index_screlease(const hsa_queue_t* queue,
|
||||
uint64_t value) {
|
||||
return coreApiTable->hsa_queue_add_write_index_release_fn(queue, value);
|
||||
return coreApiTable->hsa_queue_add_write_index_screlease_fn(queue, value);
|
||||
}
|
||||
|
||||
void HSA_API hsa_queue_store_read_index_relaxed(const hsa_queue_t* queue,
|
||||
@@ -213,9 +245,9 @@ void HSA_API hsa_queue_store_read_index_relaxed(const hsa_queue_t* queue,
|
||||
return coreApiTable->hsa_queue_store_read_index_relaxed_fn(queue, value);
|
||||
}
|
||||
|
||||
void HSA_API hsa_queue_store_read_index_release(const hsa_queue_t* queue,
|
||||
void HSA_API hsa_queue_store_read_index_screlease(const hsa_queue_t* queue,
|
||||
uint64_t value) {
|
||||
return coreApiTable->hsa_queue_store_read_index_release_fn(queue, value);
|
||||
return coreApiTable->hsa_queue_store_read_index_screlease_fn(queue, value);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API hsa_agent_iterate_regions(
|
||||
@@ -271,8 +303,8 @@ hsa_signal_value_t HSA_API hsa_signal_load_relaxed(hsa_signal_t signal) {
|
||||
return coreApiTable->hsa_signal_load_relaxed_fn(signal);
|
||||
}
|
||||
|
||||
hsa_signal_value_t HSA_API hsa_signal_load_acquire(hsa_signal_t signal) {
|
||||
return coreApiTable->hsa_signal_load_acquire_fn(signal);
|
||||
hsa_signal_value_t HSA_API hsa_signal_load_scacquire(hsa_signal_t signal) {
|
||||
return coreApiTable->hsa_signal_load_scacquire_fn(signal);
|
||||
}
|
||||
|
||||
void HSA_API
|
||||
@@ -281,8 +313,18 @@ void HSA_API
|
||||
}
|
||||
|
||||
void HSA_API
|
||||
hsa_signal_store_release(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_store_release_fn(signal, value);
|
||||
hsa_signal_store_screlease(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_store_screlease_fn(signal, value);
|
||||
}
|
||||
|
||||
void HSA_API hsa_signal_silent_store_relaxed(hsa_signal_t signal, hsa_signal_value_t value)
|
||||
{
|
||||
return coreApiTable->hsa_signal_silent_store_relaxed_fn(signal, value);
|
||||
}
|
||||
|
||||
void HSA_API hsa_signal_silent_store_screlease(hsa_signal_t signal, hsa_signal_value_t value)
|
||||
{
|
||||
return coreApiTable->hsa_signal_silent_store_screlease_fn(signal, value);
|
||||
}
|
||||
|
||||
hsa_signal_value_t HSA_API
|
||||
@@ -296,33 +338,53 @@ hsa_signal_value_t HSA_API
|
||||
}
|
||||
|
||||
hsa_signal_value_t HSA_API
|
||||
hsa_signal_wait_acquire(hsa_signal_t signal,
|
||||
hsa_signal_wait_scacquire(hsa_signal_t signal,
|
||||
hsa_signal_condition_t condition,
|
||||
hsa_signal_value_t compare_value,
|
||||
uint64_t timeout_hint,
|
||||
hsa_wait_state_t wait_expectancy_hint) {
|
||||
return coreApiTable->hsa_signal_wait_acquire_fn(
|
||||
return coreApiTable->hsa_signal_wait_scacquire_fn(
|
||||
signal, condition, compare_value, timeout_hint, wait_expectancy_hint);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API hsa_signal_group_create(uint32_t num_signals, const hsa_signal_t *signals, uint32_t num_consumers, const hsa_agent_t *consumers, hsa_signal_group_t *signal_group)
|
||||
{
|
||||
return coreApiTable->hsa_signal_group_create_fn(num_signals, signals, num_consumers, consumers, signal_group);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API hsa_signal_group_destroy(hsa_signal_group_t signal_group)
|
||||
{
|
||||
return coreApiTable->hsa_signal_group_destroy_fn(signal_group);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API hsa_signal_group_wait_any_relaxed(hsa_signal_group_t signal_group, const hsa_signal_condition_t *conditions, const hsa_signal_value_t *compare_values, hsa_wait_state_t wait_state_hint, hsa_signal_t *signal, hsa_signal_value_t *value)
|
||||
{
|
||||
return coreApiTable->hsa_signal_group_wait_any_relaxed_fn(signal_group, conditions, compare_values, wait_state_hint, signal, value);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API hsa_signal_group_wait_any_scacquire(hsa_signal_group_t signal_group, const hsa_signal_condition_t *conditions, const hsa_signal_value_t *compare_values, hsa_wait_state_t wait_state_hint, hsa_signal_t *signal, hsa_signal_value_t *value)
|
||||
{
|
||||
return coreApiTable->hsa_signal_group_wait_any_scacquire_fn(signal_group, conditions, compare_values, wait_state_hint, signal, value);
|
||||
}
|
||||
|
||||
void HSA_API
|
||||
hsa_signal_and_relaxed(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_and_relaxed_fn(signal, value);
|
||||
}
|
||||
|
||||
void HSA_API
|
||||
hsa_signal_and_acquire(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_and_acquire_fn(signal, value);
|
||||
hsa_signal_and_scacquire(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_and_scacquire_fn(signal, value);
|
||||
}
|
||||
|
||||
void HSA_API
|
||||
hsa_signal_and_release(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_and_release_fn(signal, value);
|
||||
hsa_signal_and_screlease(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_and_screlease_fn(signal, value);
|
||||
}
|
||||
|
||||
void HSA_API
|
||||
hsa_signal_and_acq_rel(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_and_acq_rel_fn(signal, value);
|
||||
hsa_signal_and_scacq_screl(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_and_scacq_screl_fn(signal, value);
|
||||
}
|
||||
|
||||
void HSA_API
|
||||
@@ -331,18 +393,18 @@ void HSA_API
|
||||
}
|
||||
|
||||
void HSA_API
|
||||
hsa_signal_or_acquire(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_or_acquire_fn(signal, value);
|
||||
hsa_signal_or_scacquire(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_or_scacquire_fn(signal, value);
|
||||
}
|
||||
|
||||
void HSA_API
|
||||
hsa_signal_or_release(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_or_release_fn(signal, value);
|
||||
hsa_signal_or_screlease(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_or_screlease_fn(signal, value);
|
||||
}
|
||||
|
||||
void HSA_API
|
||||
hsa_signal_or_acq_rel(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_or_acq_rel_fn(signal, value);
|
||||
hsa_signal_or_scacq_screl(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_or_scacq_screl_fn(signal, value);
|
||||
}
|
||||
|
||||
void HSA_API
|
||||
@@ -351,18 +413,18 @@ void HSA_API
|
||||
}
|
||||
|
||||
void HSA_API
|
||||
hsa_signal_xor_acquire(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_xor_acquire_fn(signal, value);
|
||||
hsa_signal_xor_scacquire(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_xor_scacquire_fn(signal, value);
|
||||
}
|
||||
|
||||
void HSA_API
|
||||
hsa_signal_xor_release(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_xor_release_fn(signal, value);
|
||||
hsa_signal_xor_screlease(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_xor_screlease_fn(signal, value);
|
||||
}
|
||||
|
||||
void HSA_API
|
||||
hsa_signal_xor_acq_rel(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_xor_acq_rel_fn(signal, value);
|
||||
hsa_signal_xor_scacq_screl(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_xor_scacq_screl_fn(signal, value);
|
||||
}
|
||||
|
||||
void HSA_API
|
||||
@@ -371,18 +433,18 @@ void HSA_API
|
||||
}
|
||||
|
||||
void HSA_API
|
||||
hsa_signal_add_acquire(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_add_acquire_fn(signal, value);
|
||||
hsa_signal_add_scacquire(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_add_scacquire_fn(signal, value);
|
||||
}
|
||||
|
||||
void HSA_API
|
||||
hsa_signal_add_release(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_add_release_fn(signal, value);
|
||||
hsa_signal_add_screlease(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_add_screlease_fn(signal, value);
|
||||
}
|
||||
|
||||
void HSA_API
|
||||
hsa_signal_add_acq_rel(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_add_acq_rel_fn(signal, value);
|
||||
hsa_signal_add_scacq_screl(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_add_scacq_screl_fn(signal, value);
|
||||
}
|
||||
|
||||
void HSA_API
|
||||
@@ -391,18 +453,18 @@ void HSA_API
|
||||
}
|
||||
|
||||
void HSA_API
|
||||
hsa_signal_subtract_acquire(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_subtract_acquire_fn(signal, value);
|
||||
hsa_signal_subtract_scacquire(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_subtract_scacquire_fn(signal, value);
|
||||
}
|
||||
|
||||
void HSA_API
|
||||
hsa_signal_subtract_release(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_subtract_release_fn(signal, value);
|
||||
hsa_signal_subtract_screlease(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_subtract_screlease_fn(signal, value);
|
||||
}
|
||||
|
||||
void HSA_API
|
||||
hsa_signal_subtract_acq_rel(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_subtract_acq_rel_fn(signal, value);
|
||||
hsa_signal_subtract_scacq_screl(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_subtract_scacq_screl_fn(signal, value);
|
||||
}
|
||||
|
||||
hsa_signal_value_t HSA_API
|
||||
@@ -411,18 +473,18 @@ hsa_signal_value_t HSA_API
|
||||
}
|
||||
|
||||
hsa_signal_value_t HSA_API
|
||||
hsa_signal_exchange_acquire(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_exchange_acquire_fn(signal, value);
|
||||
hsa_signal_exchange_scacquire(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_exchange_scacquire_fn(signal, value);
|
||||
}
|
||||
|
||||
hsa_signal_value_t HSA_API
|
||||
hsa_signal_exchange_release(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_exchange_release_fn(signal, value);
|
||||
hsa_signal_exchange_screlease(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_exchange_screlease_fn(signal, value);
|
||||
}
|
||||
|
||||
hsa_signal_value_t HSA_API
|
||||
hsa_signal_exchange_acq_rel(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_exchange_acq_rel_fn(signal, value);
|
||||
hsa_signal_exchange_scacq_screl(hsa_signal_t signal, hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_exchange_scacq_screl_fn(signal, value);
|
||||
}
|
||||
|
||||
hsa_signal_value_t HSA_API hsa_signal_cas_relaxed(hsa_signal_t signal,
|
||||
@@ -431,184 +493,359 @@ hsa_signal_value_t HSA_API hsa_signal_cas_relaxed(hsa_signal_t signal,
|
||||
return coreApiTable->hsa_signal_cas_relaxed_fn(signal, expected, value);
|
||||
}
|
||||
|
||||
hsa_signal_value_t HSA_API hsa_signal_cas_acquire(hsa_signal_t signal,
|
||||
hsa_signal_value_t HSA_API hsa_signal_cas_scacquire(hsa_signal_t signal,
|
||||
hsa_signal_value_t expected,
|
||||
hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_cas_acquire_fn(signal, expected, value);
|
||||
return coreApiTable->hsa_signal_cas_scacquire_fn(signal, expected, value);
|
||||
}
|
||||
|
||||
hsa_signal_value_t HSA_API hsa_signal_cas_release(hsa_signal_t signal,
|
||||
hsa_signal_value_t HSA_API hsa_signal_cas_screlease(hsa_signal_t signal,
|
||||
hsa_signal_value_t expected,
|
||||
hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_cas_release_fn(signal, expected, value);
|
||||
return coreApiTable->hsa_signal_cas_screlease_fn(signal, expected, value);
|
||||
}
|
||||
|
||||
hsa_signal_value_t HSA_API hsa_signal_cas_acq_rel(hsa_signal_t signal,
|
||||
hsa_signal_value_t HSA_API hsa_signal_cas_scacq_screl(hsa_signal_t signal,
|
||||
hsa_signal_value_t expected,
|
||||
hsa_signal_value_t value) {
|
||||
return coreApiTable->hsa_signal_cas_acq_rel_fn(signal, expected, value);
|
||||
return coreApiTable->hsa_signal_cas_scacq_screl_fn(signal, expected, value);
|
||||
}
|
||||
|
||||
hsa_status_t hsa_isa_from_name(const char* name, hsa_isa_t* isa) {
|
||||
//===--- Instruction Set Architecture -------------------------------------===//
|
||||
|
||||
hsa_status_t HSA_API hsa_isa_from_name(
|
||||
const char *name,
|
||||
hsa_isa_t *isa) {
|
||||
return coreApiTable->hsa_isa_from_name_fn(name, isa);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API hsa_isa_get_info(hsa_isa_t isa, hsa_isa_info_t attribute,
|
||||
uint32_t index, void* value) {
|
||||
hsa_status_t HSA_API hsa_agent_iterate_isas(
|
||||
hsa_agent_t agent,
|
||||
hsa_status_t (*callback)(hsa_isa_t isa,
|
||||
void *data),
|
||||
void *data) {
|
||||
return coreApiTable->hsa_agent_iterate_isas_fn(agent, callback, data);
|
||||
}
|
||||
|
||||
/* deprecated */ hsa_status_t HSA_API hsa_isa_get_info(
|
||||
hsa_isa_t isa,
|
||||
hsa_isa_info_t attribute,
|
||||
uint32_t index,
|
||||
void *value) {
|
||||
return coreApiTable->hsa_isa_get_info_fn(isa, attribute, index, value);
|
||||
}
|
||||
|
||||
hsa_status_t hsa_isa_compatible(hsa_isa_t code_object_isa, hsa_isa_t agent_isa,
|
||||
bool* result) {
|
||||
return coreApiTable->hsa_isa_compatible_fn(code_object_isa, agent_isa, result);
|
||||
hsa_status_t HSA_API hsa_isa_get_info_alt(
|
||||
hsa_isa_t isa,
|
||||
hsa_isa_info_t attribute,
|
||||
void *value) {
|
||||
return coreApiTable->hsa_isa_get_info_alt_fn(isa, attribute, value);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API hsa_code_object_serialize(
|
||||
hsa_status_t HSA_API hsa_isa_get_exception_policies(
|
||||
hsa_isa_t isa,
|
||||
hsa_profile_t profile,
|
||||
uint16_t *mask) {
|
||||
return coreApiTable->hsa_isa_get_exception_policies_fn(isa, profile, mask);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API hsa_isa_get_round_method(
|
||||
hsa_isa_t isa,
|
||||
hsa_fp_type_t fp_type,
|
||||
hsa_flush_mode_t flush_mode,
|
||||
hsa_round_method_t *round_method) {
|
||||
return coreApiTable->hsa_isa_get_round_method_fn(
|
||||
isa, fp_type, flush_mode, round_method);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API hsa_wavefront_get_info(
|
||||
hsa_wavefront_t wavefront,
|
||||
hsa_wavefront_info_t attribute,
|
||||
void *value) {
|
||||
return coreApiTable->hsa_wavefront_get_info_fn(wavefront, attribute, value);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API hsa_isa_iterate_wavefronts(
|
||||
hsa_isa_t isa,
|
||||
hsa_status_t (*callback)(hsa_wavefront_t wavefront,
|
||||
void *data),
|
||||
void *data) {
|
||||
return coreApiTable->hsa_isa_iterate_wavefronts_fn(isa, callback, data);
|
||||
}
|
||||
|
||||
/* deprecated */ hsa_status_t HSA_API hsa_isa_compatible(
|
||||
hsa_isa_t code_object_isa,
|
||||
hsa_isa_t agent_isa,
|
||||
bool *result) {
|
||||
return coreApiTable->hsa_isa_compatible_fn(
|
||||
code_object_isa, agent_isa, result);
|
||||
}
|
||||
|
||||
//===--- Code Objects (deprecated) ----------------------------------------===//
|
||||
|
||||
/* deprecated */ hsa_status_t HSA_API hsa_code_object_serialize(
|
||||
hsa_code_object_t code_object,
|
||||
hsa_status_t (*alloc_callback)(size_t size, hsa_callback_data_t data,
|
||||
void** address),
|
||||
hsa_callback_data_t callback_data, const char* options,
|
||||
void** serialized_code_object, size_t* serialized_code_object_size) {
|
||||
hsa_status_t (*alloc_callback)(size_t size,
|
||||
hsa_callback_data_t data,
|
||||
void **address),
|
||||
hsa_callback_data_t callback_data,
|
||||
const char *options,
|
||||
void **serialized_code_object,
|
||||
size_t *serialized_code_object_size) {
|
||||
return coreApiTable->hsa_code_object_serialize_fn(
|
||||
code_object, alloc_callback, callback_data, options,
|
||||
serialized_code_object, serialized_code_object_size);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API
|
||||
hsa_code_object_deserialize(void* serialized_code_object,
|
||||
size_t serialized_code_object_size,
|
||||
const char* options,
|
||||
hsa_code_object_t* code_object) {
|
||||
/* deprecated */ hsa_status_t HSA_API hsa_code_object_deserialize(
|
||||
void *serialized_code_object,
|
||||
size_t serialized_code_object_size,
|
||||
const char *options,
|
||||
hsa_code_object_t *code_object) {
|
||||
return coreApiTable->hsa_code_object_deserialize_fn(
|
||||
serialized_code_object, serialized_code_object_size, options,
|
||||
code_object);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API hsa_code_object_destroy(hsa_code_object_t code_object) {
|
||||
/* deprecated */ hsa_status_t HSA_API hsa_code_object_destroy(
|
||||
hsa_code_object_t code_object) {
|
||||
return coreApiTable->hsa_code_object_destroy_fn(code_object);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API hsa_code_object_get_info(hsa_code_object_t code_object,
|
||||
hsa_code_object_info_t attribute,
|
||||
void* value) {
|
||||
return coreApiTable->hsa_code_object_get_info_fn(code_object, attribute,
|
||||
value);
|
||||
/* deprecated */ hsa_status_t HSA_API hsa_code_object_get_info(
|
||||
hsa_code_object_t code_object,
|
||||
hsa_code_object_info_t attribute,
|
||||
void *value) {
|
||||
return coreApiTable->hsa_code_object_get_info_fn(
|
||||
code_object, attribute, value);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API hsa_code_object_get_symbol(hsa_code_object_t code_object,
|
||||
const char* symbol_name,
|
||||
hsa_code_symbol_t* symbol) {
|
||||
return coreApiTable->hsa_code_object_get_symbol_fn(code_object, symbol_name,
|
||||
symbol);
|
||||
/* deprecated */ hsa_status_t HSA_API hsa_code_object_get_symbol(
|
||||
hsa_code_object_t code_object,
|
||||
const char *symbol_name,
|
||||
hsa_code_symbol_t *symbol) {
|
||||
return coreApiTable->hsa_code_object_get_symbol_fn(
|
||||
code_object, symbol_name, symbol);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API hsa_code_symbol_get_info(hsa_code_symbol_t code_symbol,
|
||||
hsa_code_symbol_info_t attribute,
|
||||
void* value) {
|
||||
return coreApiTable->hsa_code_symbol_get_info_fn(code_symbol, attribute,
|
||||
value);
|
||||
/* deprecated */ hsa_status_t HSA_API hsa_code_object_get_symbol_from_name(
|
||||
hsa_code_object_t code_object,
|
||||
const char *module_name,
|
||||
const char *symbol_name,
|
||||
hsa_code_symbol_t *symbol) {
|
||||
return coreApiTable->hsa_code_object_get_symbol_from_name_fn(
|
||||
code_object, module_name, symbol_name, symbol);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API hsa_code_object_iterate_symbols(
|
||||
/* deprecated */ hsa_status_t HSA_API hsa_code_symbol_get_info(
|
||||
hsa_code_symbol_t code_symbol,
|
||||
hsa_code_symbol_info_t attribute,
|
||||
void *value) {
|
||||
return coreApiTable->hsa_code_symbol_get_info_fn(
|
||||
code_symbol, attribute, value);
|
||||
}
|
||||
|
||||
/* deprecated */ hsa_status_t HSA_API hsa_code_object_iterate_symbols(
|
||||
hsa_code_object_t code_object,
|
||||
hsa_status_t (*callback)(hsa_code_object_t code_object,
|
||||
hsa_code_symbol_t symbol, void* data),
|
||||
void* data) {
|
||||
return coreApiTable->hsa_code_object_iterate_symbols_fn(code_object, callback,
|
||||
data);
|
||||
hsa_code_symbol_t symbol,
|
||||
void *data),
|
||||
void *data) {
|
||||
return coreApiTable->hsa_code_object_iterate_symbols_fn(
|
||||
code_object, callback, data);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API
|
||||
hsa_executable_create(hsa_profile_t profile,
|
||||
hsa_executable_state_t executable_state,
|
||||
const char* options, hsa_executable_t* executable) {
|
||||
return coreApiTable->hsa_executable_create_fn(profile, executable_state,
|
||||
options, executable);
|
||||
//===--- Executable -------------------------------------------------------===//
|
||||
|
||||
hsa_status_t HSA_API hsa_code_object_reader_create_from_file(
|
||||
hsa_file_t file,
|
||||
hsa_code_object_reader_t *code_object_reader) {
|
||||
return coreApiTable->hsa_code_object_reader_create_from_file_fn(
|
||||
file, code_object_reader);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API hsa_executable_destroy(hsa_executable_t executable) {
|
||||
hsa_status_t HSA_API hsa_code_object_reader_create_from_memory(
|
||||
const void *code_object,
|
||||
size_t size,
|
||||
hsa_code_object_reader_t *code_object_reader) {
|
||||
return coreApiTable->hsa_code_object_reader_create_from_memory_fn(
|
||||
code_object, size, code_object_reader);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API hsa_code_object_reader_destroy(
|
||||
hsa_code_object_reader_t code_object_reader) {
|
||||
return coreApiTable->hsa_code_object_reader_destroy_fn(code_object_reader);
|
||||
}
|
||||
|
||||
/* deprecated */ hsa_status_t HSA_API hsa_executable_create(
|
||||
hsa_profile_t profile,
|
||||
hsa_executable_state_t executable_state,
|
||||
const char *options,
|
||||
hsa_executable_t *executable) {
|
||||
return coreApiTable->hsa_executable_create_fn(
|
||||
profile, executable_state, options, executable);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API hsa_executable_create_alt(
|
||||
hsa_profile_t profile,
|
||||
hsa_default_float_rounding_mode_t default_float_rounding_mode,
|
||||
const char *options,
|
||||
hsa_executable_t *executable) {
|
||||
return coreApiTable->hsa_executable_create_alt_fn(
|
||||
profile, default_float_rounding_mode, options, executable);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API hsa_executable_destroy(
|
||||
hsa_executable_t executable) {
|
||||
return coreApiTable->hsa_executable_destroy_fn(executable);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API
|
||||
hsa_executable_load_code_object(hsa_executable_t executable,
|
||||
hsa_agent_t agent,
|
||||
hsa_code_object_t code_object,
|
||||
const char* options) {
|
||||
return coreApiTable->hsa_executable_load_code_object_fn(executable, agent,
|
||||
code_object, options);
|
||||
/* deprecated */ hsa_status_t HSA_API hsa_executable_load_code_object(
|
||||
hsa_executable_t executable,
|
||||
hsa_agent_t agent,
|
||||
hsa_code_object_t code_object,
|
||||
const char *options) {
|
||||
return coreApiTable->hsa_executable_load_code_object_fn(
|
||||
executable, agent, code_object, options);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API
|
||||
hsa_executable_freeze(hsa_executable_t executable, const char* options) {
|
||||
hsa_status_t HSA_API hsa_executable_load_program_code_object(
|
||||
hsa_executable_t executable,
|
||||
hsa_code_object_reader_t code_object_reader,
|
||||
const char *options,
|
||||
hsa_loaded_code_object_t *loaded_code_object) {
|
||||
return coreApiTable->hsa_executable_load_program_code_object_fn(
|
||||
executable, code_object_reader, options, loaded_code_object);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API hsa_executable_load_agent_code_object(
|
||||
hsa_executable_t executable,
|
||||
hsa_agent_t agent,
|
||||
hsa_code_object_reader_t code_object_reader,
|
||||
const char *options,
|
||||
hsa_loaded_code_object_t *loaded_code_object) {
|
||||
return coreApiTable->hsa_executable_load_agent_code_object_fn(
|
||||
executable, agent, code_object_reader, options, loaded_code_object);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API hsa_executable_freeze(
|
||||
hsa_executable_t executable,
|
||||
const char *options) {
|
||||
return coreApiTable->hsa_executable_freeze_fn(executable, options);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API hsa_executable_get_info(hsa_executable_t executable,
|
||||
hsa_executable_info_t attribute,
|
||||
void* value) {
|
||||
hsa_status_t HSA_API hsa_executable_get_info(
|
||||
hsa_executable_t executable,
|
||||
hsa_executable_info_t attribute,
|
||||
void *value) {
|
||||
return coreApiTable->hsa_executable_get_info_fn(executable, attribute, value);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API
|
||||
hsa_executable_global_variable_define(hsa_executable_t executable,
|
||||
const char* variable_name,
|
||||
void* address) {
|
||||
hsa_status_t HSA_API hsa_executable_global_variable_define(
|
||||
hsa_executable_t executable,
|
||||
const char *variable_name,
|
||||
void *address) {
|
||||
return coreApiTable->hsa_executable_global_variable_define_fn(
|
||||
executable, variable_name, address);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API
|
||||
hsa_executable_agent_global_variable_define(hsa_executable_t executable,
|
||||
hsa_agent_t agent,
|
||||
const char* variable_name,
|
||||
void* address) {
|
||||
hsa_status_t HSA_API hsa_executable_agent_global_variable_define(
|
||||
hsa_executable_t executable,
|
||||
hsa_agent_t agent,
|
||||
const char *variable_name,
|
||||
void *address) {
|
||||
return coreApiTable->hsa_executable_agent_global_variable_define_fn(
|
||||
executable, agent, variable_name, address);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API
|
||||
hsa_executable_readonly_variable_define(hsa_executable_t executable,
|
||||
hsa_agent_t agent,
|
||||
const char* variable_name,
|
||||
void* address) {
|
||||
hsa_status_t HSA_API hsa_executable_readonly_variable_define(
|
||||
hsa_executable_t executable,
|
||||
hsa_agent_t agent,
|
||||
const char *variable_name,
|
||||
void *address) {
|
||||
return coreApiTable->hsa_executable_readonly_variable_define_fn(
|
||||
executable, agent, variable_name, address);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API
|
||||
hsa_executable_validate(hsa_executable_t executable, uint32_t* result) {
|
||||
hsa_status_t HSA_API hsa_executable_validate(
|
||||
hsa_executable_t executable,
|
||||
uint32_t *result) {
|
||||
return coreApiTable->hsa_executable_validate_fn(executable, result);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API
|
||||
hsa_executable_get_symbol(hsa_executable_t executable,
|
||||
const char* module_name, const char* symbol_name,
|
||||
hsa_agent_t agent, int32_t call_convention,
|
||||
hsa_executable_symbol_t* symbol) {
|
||||
hsa_status_t HSA_API hsa_executable_validate_alt(
|
||||
hsa_executable_t executable,
|
||||
const char *options,
|
||||
uint32_t *result) {
|
||||
return coreApiTable->hsa_executable_validate_alt_fn(
|
||||
executable, options, result);
|
||||
}
|
||||
|
||||
/* deprecated */ hsa_status_t HSA_API hsa_executable_get_symbol(
|
||||
hsa_executable_t executable,
|
||||
const char *module_name,
|
||||
const char *symbol_name,
|
||||
hsa_agent_t agent,
|
||||
int32_t call_convention,
|
||||
hsa_executable_symbol_t *symbol) {
|
||||
return coreApiTable->hsa_executable_get_symbol_fn(
|
||||
executable, module_name, symbol_name, agent, call_convention, symbol);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API
|
||||
hsa_executable_symbol_get_info(hsa_executable_symbol_t executable_symbol,
|
||||
hsa_executable_symbol_info_t attribute,
|
||||
void* value) {
|
||||
return coreApiTable->hsa_executable_symbol_get_info_fn(executable_symbol,
|
||||
attribute, value);
|
||||
hsa_status_t HSA_API hsa_executable_get_symbol_by_name(
|
||||
hsa_executable_t executable,
|
||||
const char *symbol_name,
|
||||
const hsa_agent_t *agent,
|
||||
hsa_executable_symbol_t *symbol) {
|
||||
return coreApiTable->hsa_executable_get_symbol_by_name_fn(
|
||||
executable, symbol_name, agent, symbol);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API hsa_executable_iterate_symbols(
|
||||
hsa_status_t HSA_API hsa_executable_symbol_get_info(
|
||||
hsa_executable_symbol_t executable_symbol,
|
||||
hsa_executable_symbol_info_t attribute,
|
||||
void *value) {
|
||||
return coreApiTable->hsa_executable_symbol_get_info_fn(
|
||||
executable_symbol, attribute, value);
|
||||
}
|
||||
|
||||
/* deprecated */ hsa_status_t HSA_API hsa_executable_iterate_symbols(
|
||||
hsa_executable_t executable,
|
||||
hsa_status_t (*callback)(hsa_executable_t executable,
|
||||
hsa_executable_symbol_t symbol, void* data),
|
||||
void* data) {
|
||||
return coreApiTable->hsa_executable_iterate_symbols_fn(executable, callback,
|
||||
data);
|
||||
hsa_executable_symbol_t symbol,
|
||||
void *data),
|
||||
void *data) {
|
||||
return coreApiTable->hsa_executable_iterate_symbols_fn(
|
||||
executable, callback, data);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API
|
||||
hsa_status_string(hsa_status_t status, const char** status_string) {
|
||||
hsa_status_t HSA_API hsa_executable_iterate_agent_symbols(
|
||||
hsa_executable_t executable,
|
||||
hsa_agent_t agent,
|
||||
hsa_status_t (*callback)(hsa_executable_t exec,
|
||||
hsa_agent_t agent,
|
||||
hsa_executable_symbol_t symbol,
|
||||
void *data),
|
||||
void *data) {
|
||||
return coreApiTable->hsa_executable_iterate_agent_symbols_fn(
|
||||
executable, agent, callback, data);
|
||||
}
|
||||
|
||||
hsa_status_t HSA_API hsa_executable_iterate_program_symbols(
|
||||
hsa_executable_t executable,
|
||||
hsa_status_t (*callback)(hsa_executable_t exec,
|
||||
hsa_executable_symbol_t symbol,
|
||||
void *data),
|
||||
void *data) {
|
||||
return coreApiTable->hsa_executable_iterate_program_symbols_fn(
|
||||
executable, callback, data);
|
||||
}
|
||||
|
||||
//===--- Runtime Notifications --------------------------------------------===//
|
||||
|
||||
hsa_status_t HSA_API hsa_status_string(
|
||||
hsa_status_t status,
|
||||
const char **status_string) {
|
||||
return coreApiTable->hsa_status_string_fn(status, status_string);
|
||||
}
|
||||
|
||||
|
||||
@@ -1,34 +1,49 @@
|
||||
ROCR_1
|
||||
{
|
||||
global:
|
||||
hsa_init;
|
||||
hsa_shut_down;
|
||||
hsa_system_get_info;
|
||||
hsa_extension_get_name;
|
||||
hsa_system_extension_supported;
|
||||
hsa_system_major_extension_supported;
|
||||
hsa_system_get_extension_table;
|
||||
hsa_system_get_major_extension_table;
|
||||
hsa_iterate_agents;
|
||||
hsa_agent_get_info;
|
||||
hsa_agent_get_exception_policies;
|
||||
hsa_cache_get_info;
|
||||
hsa_agent_iterate_caches;
|
||||
hsa_agent_extension_supported;
|
||||
hsa_agent_major_extension_supported;
|
||||
hsa_queue_create;
|
||||
hsa_soft_queue_create;
|
||||
hsa_queue_destroy;
|
||||
hsa_queue_inactivate;
|
||||
hsa_queue_load_read_index_scacquire;
|
||||
hsa_queue_load_read_index_acquire;
|
||||
hsa_queue_load_read_index_relaxed;
|
||||
hsa_queue_load_write_index_scacquire;
|
||||
hsa_queue_load_write_index_acquire;
|
||||
hsa_queue_load_write_index_relaxed;
|
||||
hsa_queue_store_write_index_relaxed;
|
||||
hsa_queue_store_write_index_screlease;
|
||||
hsa_queue_store_write_index_release;
|
||||
hsa_queue_cas_write_index_scacq_screl;
|
||||
hsa_queue_cas_write_index_acq_rel;
|
||||
hsa_queue_cas_write_index_scacquire;
|
||||
hsa_queue_cas_write_index_acquire;
|
||||
hsa_queue_cas_write_index_relaxed;
|
||||
hsa_queue_cas_write_index_screlease;
|
||||
hsa_queue_cas_write_index_release;
|
||||
hsa_queue_add_write_index_scacq_screl;
|
||||
hsa_queue_add_write_index_acq_rel;
|
||||
hsa_queue_add_write_index_scacquire;
|
||||
hsa_queue_add_write_index_acquire;
|
||||
hsa_queue_add_write_index_relaxed;
|
||||
hsa_queue_add_write_index_screlease;
|
||||
hsa_queue_add_write_index_release;
|
||||
hsa_queue_store_read_index_relaxed;
|
||||
hsa_queue_store_read_index_screlease;
|
||||
hsa_queue_store_read_index_release;
|
||||
hsa_agent_iterate_regions;
|
||||
hsa_region_get_info;
|
||||
@@ -41,61 +56,107 @@ global:
|
||||
hsa_signal_create;
|
||||
hsa_signal_destroy;
|
||||
hsa_signal_load_relaxed;
|
||||
hsa_signal_load_scacquire;
|
||||
hsa_signal_load_acquire;
|
||||
hsa_signal_store_relaxed;
|
||||
hsa_signal_store_screlease;
|
||||
hsa_signal_store_release;
|
||||
hsa_signal_silent_store_relaxed;
|
||||
hsa_signal_silent_store_screlease;
|
||||
hsa_signal_wait_relaxed;
|
||||
hsa_signal_wait_scacquire;
|
||||
hsa_signal_wait_acquire;
|
||||
hsa_signal_group_create;
|
||||
hsa_signal_group_destroy;
|
||||
hsa_signal_group_wait_any_scacquire;
|
||||
hsa_signal_and_relaxed;
|
||||
hsa_signal_and_scacquire;
|
||||
hsa_signal_and_acquire;
|
||||
hsa_signal_and_screlease;
|
||||
hsa_signal_and_release;
|
||||
hsa_signal_and_scacq_screl;
|
||||
hsa_signal_and_acq_rel;
|
||||
hsa_signal_or_relaxed;
|
||||
hsa_signal_or_scacquire;
|
||||
hsa_signal_or_acquire;
|
||||
hsa_signal_or_screlease;
|
||||
hsa_signal_or_release;
|
||||
hsa_signal_or_scacq_screl;
|
||||
hsa_signal_or_acq_rel;
|
||||
hsa_signal_xor_relaxed;
|
||||
hsa_signal_xor_scacquire;
|
||||
hsa_signal_xor_acquire;
|
||||
hsa_signal_xor_screlease;
|
||||
hsa_signal_xor_release;
|
||||
hsa_signal_xor_scacq_screl;
|
||||
hsa_signal_xor_acq_rel;
|
||||
hsa_signal_exchange_relaxed;
|
||||
hsa_signal_exchange_scacquire;
|
||||
hsa_signal_exchange_acquire;
|
||||
hsa_signal_exchange_screlease;
|
||||
hsa_signal_exchange_release;
|
||||
hsa_signal_exchange_scacq_screl;
|
||||
hsa_signal_exchange_acq_rel;
|
||||
hsa_signal_add_relaxed;
|
||||
hsa_signal_add_scacquire;
|
||||
hsa_signal_add_acquire;
|
||||
hsa_signal_add_screlease;
|
||||
hsa_signal_add_release;
|
||||
hsa_signal_add_scacq_screl;
|
||||
hsa_signal_add_acq_rel;
|
||||
hsa_signal_subtract_relaxed;
|
||||
hsa_signal_subtract_scacquire;
|
||||
hsa_signal_subtract_acquire;
|
||||
hsa_signal_subtract_screlease;
|
||||
hsa_signal_subtract_release;
|
||||
hsa_signal_subtract_scacq_screl;
|
||||
hsa_signal_subtract_acq_rel;
|
||||
hsa_signal_cas_relaxed;
|
||||
hsa_signal_cas_scacquire;
|
||||
hsa_signal_cas_acquire;
|
||||
hsa_signal_cas_screlease;
|
||||
hsa_signal_cas_release;
|
||||
hsa_signal_cas_scacq_screl;
|
||||
hsa_signal_cas_acq_rel;
|
||||
hsa_isa_from_name;
|
||||
hsa_agent_iterate_isas;
|
||||
hsa_isa_get_info;
|
||||
hsa_isa_get_info_alt;
|
||||
hsa_isa_get_exception_policies;
|
||||
hsa_isa_get_round_method;
|
||||
hsa_wavefront_get_info;
|
||||
hsa_isa_iterate_wavefronts;
|
||||
hsa_isa_compatible;
|
||||
hsa_code_object_serialize;
|
||||
hsa_code_object_deserialize;
|
||||
hsa_code_object_destroy;
|
||||
hsa_code_object_get_info;
|
||||
hsa_code_object_get_symbol;
|
||||
hsa_code_object_get_symbol_from_name;
|
||||
hsa_code_symbol_get_info;
|
||||
hsa_code_object_iterate_symbols;
|
||||
hsa_code_object_reader_create_from_file;
|
||||
hsa_code_object_reader_create_from_memory;
|
||||
hsa_code_object_reader_destroy;
|
||||
hsa_executable_create;
|
||||
hsa_executable_create_alt;
|
||||
hsa_executable_destroy;
|
||||
hsa_executable_load_code_object;
|
||||
hsa_executable_load_program_code_object;
|
||||
hsa_executable_load_agent_code_object;
|
||||
hsa_executable_freeze;
|
||||
hsa_executable_get_info;
|
||||
hsa_executable_global_variable_define;
|
||||
hsa_executable_agent_global_variable_define;
|
||||
hsa_executable_readonly_variable_define;
|
||||
hsa_executable_validate;
|
||||
hsa_executable_validate_alt;
|
||||
hsa_executable_get_symbol;
|
||||
hsa_executable_get_symbol_by_name;
|
||||
hsa_executable_symbol_get_info;
|
||||
hsa_executable_iterate_symbols;
|
||||
hsa_executable_iterate_agent_symbols;
|
||||
hsa_executable_iterate_program_symbols;
|
||||
hsa_status_string;
|
||||
hsa_ext_program_create;
|
||||
hsa_ext_program_destroy;
|
||||
|
||||
@@ -0,0 +1,34 @@
|
||||
hsa_queue_load_read_index_acquire = hsa_queue_load_read_index_scacquire;
|
||||
hsa_queue_load_write_index_acquire = hsa_queue_load_write_index_scacquire;
|
||||
hsa_queue_store_write_index_release = hsa_queue_store_write_index_screlease;
|
||||
hsa_queue_cas_write_index_acq_rel = hsa_queue_cas_write_index_scacq_screl;
|
||||
hsa_queue_cas_write_index_acquire = hsa_queue_cas_write_index_scacquire;
|
||||
hsa_queue_cas_write_index_release = hsa_queue_cas_write_index_screlease;
|
||||
hsa_queue_add_write_index_acq_rel = hsa_queue_add_write_index_scacq_screl;
|
||||
hsa_queue_add_write_index_acquire = hsa_queue_add_write_index_scacquire;
|
||||
hsa_queue_add_write_index_release = hsa_queue_add_write_index_screlease;
|
||||
hsa_queue_store_read_index_release = hsa_queue_store_read_index_screlease;
|
||||
hsa_signal_load_acquire = hsa_signal_load_scacquire;
|
||||
hsa_signal_store_release = hsa_signal_store_screlease;
|
||||
hsa_signal_wait_acquire = hsa_signal_wait_scacquire;
|
||||
hsa_signal_and_acquire = hsa_signal_and_scacquire;
|
||||
hsa_signal_and_release = hsa_signal_and_screlease;
|
||||
hsa_signal_and_acq_rel = hsa_signal_and_scacq_screl;
|
||||
hsa_signal_or_acquire = hsa_signal_or_scacquire;
|
||||
hsa_signal_or_release = hsa_signal_or_screlease;
|
||||
hsa_signal_or_acq_rel = hsa_signal_or_scacq_screl;
|
||||
hsa_signal_xor_acquire = hsa_signal_xor_scacquire;
|
||||
hsa_signal_xor_release = hsa_signal_xor_screlease;
|
||||
hsa_signal_xor_acq_rel = hsa_signal_xor_scacq_screl;
|
||||
hsa_signal_exchange_acquire = hsa_signal_exchange_scacquire;
|
||||
hsa_signal_exchange_release = hsa_signal_exchange_screlease;
|
||||
hsa_signal_exchange_acq_rel = hsa_signal_exchange_scacq_screl;
|
||||
hsa_signal_add_acquire = hsa_signal_add_scacquire;
|
||||
hsa_signal_add_release = hsa_signal_add_screlease;
|
||||
hsa_signal_add_acq_rel = hsa_signal_add_scacq_screl;
|
||||
hsa_signal_subtract_acquire = hsa_signal_subtract_scacquire;
|
||||
hsa_signal_subtract_release = hsa_signal_subtract_screlease;
|
||||
hsa_signal_subtract_acq_rel = hsa_signal_subtract_scacq_screl;
|
||||
hsa_signal_cas_acquire = hsa_signal_cas_scacquire;
|
||||
hsa_signal_cas_release = hsa_signal_cas_screlease;
|
||||
hsa_signal_cas_acq_rel = hsa_signal_cas_scacq_screl;
|
||||
@@ -190,6 +190,9 @@ class Agent : public Checked<0xF6BC25EB17E6F917> {
|
||||
hsa_status_t (*callback)(hsa_region_t region, void* data),
|
||||
void* data) const = 0;
|
||||
|
||||
// @brief Invoke the callback for each cache useable by this agent.
|
||||
virtual hsa_status_t IterateCache(hsa_status_t (*callback )(hsa_cache_t cache, void *data), void* data) const = 0;
|
||||
|
||||
// @brief Create queue.
|
||||
//
|
||||
// @param [in] size Number of packets the queue is expected to hold. Must be a
|
||||
|
||||
@@ -52,6 +52,7 @@
|
||||
#include "core/inc/runtime.h"
|
||||
#include "core/inc/agent.h"
|
||||
#include "core/inc/queue.h"
|
||||
#include "core/inc/cache.h"
|
||||
|
||||
namespace amd {
|
||||
// @brief Class to represent a CPU device.
|
||||
@@ -88,6 +89,9 @@ class CpuAgent : public core::Agent {
|
||||
void* data),
|
||||
void* data) const override;
|
||||
|
||||
// @brief Override from core::Agent.
|
||||
hsa_status_t IterateCache(hsa_status_t (*callback )(hsa_cache_t cache, void *data), void* value) const override;
|
||||
|
||||
// @brief Override from core::Agent.
|
||||
hsa_status_t GetInfo(hsa_agent_info_t attribute, void* value) const override;
|
||||
|
||||
@@ -143,6 +147,9 @@ class CpuAgent : public core::Agent {
|
||||
// level.
|
||||
std::vector<HsaCacheProperties> cache_props_;
|
||||
|
||||
// @brief Array of HSA cache objects.
|
||||
std::vector<std::unique_ptr<core::Cache>> caches_;
|
||||
|
||||
// @brief Array of regions owned by this agent.
|
||||
std::vector<const core::MemoryRegion*> regions_;
|
||||
|
||||
|
||||
@@ -53,6 +53,7 @@
|
||||
#include "core/inc/agent.h"
|
||||
#include "core/inc/blit.h"
|
||||
#include "core/inc/signal.h"
|
||||
#include "core/inc/cache.h"
|
||||
#include "core/util/small_heap.h"
|
||||
#include "core/util/locks.h"
|
||||
|
||||
@@ -222,6 +223,9 @@ class GpuAgent : public GpuAgentInt {
|
||||
void* data),
|
||||
void* data) const override;
|
||||
|
||||
// @brief Override from core::Agent.
|
||||
hsa_status_t IterateCache(hsa_status_t (*callback )(hsa_cache_t cache, void *data), void* value) const override;
|
||||
|
||||
// @brief Override from core::Agent.
|
||||
hsa_status_t DmaCopy(void* dst, const void* src, size_t size) override;
|
||||
|
||||
@@ -402,6 +406,9 @@ class GpuAgent : public GpuAgentInt {
|
||||
// @brief Array of GPU cache property.
|
||||
std::vector<HsaCacheProperties> cache_props_;
|
||||
|
||||
// @brief Array of HSA cache objects.
|
||||
std::vector<std::unique_ptr<core::Cache>> caches_;
|
||||
|
||||
// @brief Array of regions owned by this agent.
|
||||
std::vector<const core::MemoryRegion*> regions_;
|
||||
|
||||
|
||||
@@ -73,15 +73,10 @@ typedef uint32_t hsa_symbol_info32_t;
|
||||
typedef hsa_executable_symbol_t hsa_symbol_t;
|
||||
typedef hsa_executable_symbol_info_t hsa_symbol_info_t;
|
||||
|
||||
/// @brief Loaded code object handle.
|
||||
typedef struct amd_loaded_code_object_s {
|
||||
uint64_t handle;
|
||||
} amd_loaded_code_object_t;
|
||||
|
||||
/// @brief Loaded code object attributes.
|
||||
enum amd_loaded_code_object_info_t {
|
||||
AMD_LOADED_CODE_OBJECT_INFO_ELF_IMAGE = 0,
|
||||
AMD_LOADED_CODE_OBJECT_INFO_ELF_IMAGE_SIZE = 1
|
||||
enum hsa_loaded_code_object_info_t {
|
||||
HSA_LOADED_CODE_OBJECT_INFO_ELF_IMAGE = 0,
|
||||
HSA_LOADED_CODE_OBJECT_INFO_ELF_IMAGE_SIZE = 1
|
||||
};
|
||||
|
||||
/// @brief Loaded segment handle.
|
||||
@@ -175,6 +170,8 @@ public:
|
||||
|
||||
virtual bool GetInfo(hsa_symbol_info32_t symbol_info, void *value) = 0;
|
||||
|
||||
virtual hsa_agent_t GetAgent() = 0;
|
||||
|
||||
protected:
|
||||
Symbol() {}
|
||||
|
||||
@@ -189,13 +186,13 @@ private:
|
||||
|
||||
class LoadedCodeObject {
|
||||
public:
|
||||
static amd_loaded_code_object_t Handle(LoadedCodeObject *object) {
|
||||
amd_loaded_code_object_t handle =
|
||||
static hsa_loaded_code_object_t Handle(LoadedCodeObject *object) {
|
||||
hsa_loaded_code_object_t handle =
|
||||
{reinterpret_cast<uint64_t>(object)};
|
||||
return handle;
|
||||
}
|
||||
|
||||
static LoadedCodeObject* Object(amd_loaded_code_object_t handle) {
|
||||
static LoadedCodeObject* Object(hsa_loaded_code_object_t handle) {
|
||||
LoadedCodeObject *object =
|
||||
reinterpret_cast<LoadedCodeObject*>(handle.handle);
|
||||
return object;
|
||||
@@ -203,7 +200,7 @@ public:
|
||||
|
||||
virtual ~LoadedCodeObject() {}
|
||||
|
||||
virtual bool GetInfo(amd_loaded_code_object_info_t attribute, void *value) = 0;
|
||||
virtual bool GetInfo(hsa_loaded_code_object_info_t attribute, void *value) = 0;
|
||||
|
||||
virtual hsa_status_t IterateLoadedSegments(
|
||||
hsa_status_t (*callback)(
|
||||
@@ -285,24 +282,28 @@ public:
|
||||
hsa_agent_t agent,
|
||||
hsa_code_object_t code_object,
|
||||
const char *options,
|
||||
amd_loaded_code_object_t *loaded_code_object = nullptr) = 0;
|
||||
hsa_loaded_code_object_t *loaded_code_object = nullptr,
|
||||
bool load_legacy = true) = 0;
|
||||
|
||||
virtual hsa_status_t LoadCodeObject(
|
||||
hsa_agent_t agent,
|
||||
hsa_code_object_t code_object,
|
||||
size_t code_object_size,
|
||||
const char *options,
|
||||
amd_loaded_code_object_t *loaded_code_object = nullptr) = 0;
|
||||
hsa_loaded_code_object_t *loaded_code_object = nullptr,
|
||||
bool load_legacy = true) = 0;
|
||||
|
||||
virtual hsa_status_t Freeze(const char *options) = 0;
|
||||
|
||||
virtual hsa_status_t Validate(uint32_t *result) = 0;
|
||||
|
||||
/// @note needed for hsa v1.0.
|
||||
/// @todo remove during loader refactoring.
|
||||
virtual bool IsProgramSymbol(const char *symbol_name) = 0;
|
||||
|
||||
virtual Symbol* GetSymbol(
|
||||
const char *module_name,
|
||||
const char *symbol_name,
|
||||
hsa_agent_t agent,
|
||||
int32_t call_convention) = 0;
|
||||
const hsa_agent_t *agent) = 0;
|
||||
|
||||
typedef hsa_status_t (*iterate_symbols_f)(
|
||||
hsa_executable_t executable,
|
||||
@@ -312,9 +313,25 @@ public:
|
||||
virtual hsa_status_t IterateSymbols(
|
||||
iterate_symbols_f callback, void *data) = 0;
|
||||
|
||||
/// @since hsa v1.1.
|
||||
virtual hsa_status_t IterateAgentSymbols(
|
||||
hsa_agent_t agent,
|
||||
hsa_status_t (*callback)(hsa_executable_t exec,
|
||||
hsa_agent_t agent,
|
||||
hsa_executable_symbol_t symbol,
|
||||
void *data),
|
||||
void *data) = 0;
|
||||
|
||||
/// @since hsa v1.1.
|
||||
virtual hsa_status_t IterateProgramSymbols(
|
||||
hsa_status_t (*callback)(hsa_executable_t exec,
|
||||
hsa_executable_symbol_t symbol,
|
||||
void *data),
|
||||
void *data) = 0;
|
||||
|
||||
virtual hsa_status_t IterateLoadedCodeObjects(
|
||||
hsa_status_t (*callback)(
|
||||
amd_loaded_code_object_t loaded_code_object,
|
||||
hsa_loaded_code_object_t loaded_code_object,
|
||||
void *data),
|
||||
void *data) = 0;
|
||||
|
||||
@@ -364,7 +381,10 @@ public:
|
||||
|
||||
/// @brief Creates empty AMD HSA Executable with specified @p profile,
|
||||
/// @p options
|
||||
virtual Executable* CreateExecutable(hsa_profile_t profile, const char *options) = 0;
|
||||
virtual Executable* CreateExecutable(
|
||||
hsa_profile_t profile,
|
||||
const char *options,
|
||||
hsa_default_float_rounding_mode_t default_float_rounding_mode = HSA_DEFAULT_FLOAT_ROUNDING_MODE_DEFAULT) = 0;
|
||||
|
||||
/// @brief Destroys @p executable
|
||||
virtual void DestroyExecutable(Executable *executable) = 0;
|
||||
|
||||
@@ -0,0 +1,86 @@
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// The University of Illinois/NCSA
|
||||
// Open Source License (NCSA)
|
||||
//
|
||||
// Copyright (c) 2014-2015, Advanced Micro Devices, Inc. All rights reserved.
|
||||
//
|
||||
// Developed by:
|
||||
//
|
||||
// AMD Research and AMD HSA Software Development
|
||||
//
|
||||
// Advanced Micro Devices, Inc.
|
||||
//
|
||||
// www.amd.com
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
// of this software and associated documentation files (the "Software"), to
|
||||
// deal with the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// - Redistributions of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimers.
|
||||
// - Redistributions in binary form must reproduce the above copyright
|
||||
// notice, this list of conditions and the following disclaimers in
|
||||
// the documentation and/or other materials provided with the distribution.
|
||||
// - Neither the names of Advanced Micro Devices, Inc,
|
||||
// nor the names of its contributors may be used to endorse or promote
|
||||
// products derived from this Software without specific prior written
|
||||
// permission.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
||||
// THE CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
||||
// OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||
// DEALINGS WITH THE SOFTWARE.
|
||||
//
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef HSA_RUNTIME_CORE_INC_CACHE_H
|
||||
#define HSA_RUNTIME_CORE_INC_CACHE_H
|
||||
|
||||
#include "core/inc/hsa_internal.h"
|
||||
#include "core/inc/checked.h"
|
||||
#include "core/util/utils.h"
|
||||
#include <utility>
|
||||
#include <string>
|
||||
|
||||
namespace core
|
||||
{
|
||||
|
||||
class Cache : public Checked<0x39A6C7AD3F135B06>
|
||||
{
|
||||
public:
|
||||
static __forceinline hsa_cache_t Convert(const Cache* cache)
|
||||
{
|
||||
const hsa_cache_t handle={ static_cast<uint64_t>(reinterpret_cast<uintptr_t>(cache)) };
|
||||
return handle;
|
||||
}
|
||||
static __forceinline Cache* Convert(const hsa_cache_t cache)
|
||||
{
|
||||
return reinterpret_cast<Cache*>(static_cast<uintptr_t>(cache.handle));
|
||||
}
|
||||
|
||||
Cache(const std::string& name, uint8_t level, uint32_t size) : name_(name), level_(level), size_(size) {}
|
||||
|
||||
Cache(std::string&& name, uint8_t level, uint32_t size) : name_(std::move(name)), level_(level), size_(size) {}
|
||||
|
||||
hsa_status_t GetInfo(hsa_cache_info_t attribute, void* value);
|
||||
|
||||
private:
|
||||
|
||||
std::string name_;
|
||||
uint32_t level_;
|
||||
uint32_t size_;
|
||||
|
||||
// Forbid copying and moving of this object
|
||||
DISALLOW_COPY_AND_ASSIGN(Cache);
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif // HSA_RUNTIME_CORE_INC_CACHE_H
|
||||
@@ -53,12 +53,16 @@ namespace HSA
|
||||
hsa_status_t HSA_API hsa_shut_down();
|
||||
hsa_status_t HSA_API
|
||||
hsa_system_get_info(hsa_system_info_t attribute, void *value);
|
||||
hsa_status_t HSA_API hsa_extension_get_name(uint16_t extension, const char **name);
|
||||
hsa_status_t HSA_API hsa_system_extension_supported(uint16_t extension, uint16_t version_major,
|
||||
uint16_t version_minor, bool* result);
|
||||
hsa_status_t HSA_API
|
||||
hsa_system_extension_supported(uint16_t extension, uint16_t version_major,
|
||||
uint16_t version_minor, bool *result);
|
||||
hsa_system_major_extension_supported(uint16_t extension, uint16_t version_major,
|
||||
uint16_t *version_minor, bool *result);
|
||||
hsa_status_t HSA_API
|
||||
hsa_system_get_extension_table(uint16_t extension, uint16_t version_major,
|
||||
uint16_t version_minor, void *table);
|
||||
hsa_status_t HSA_API hsa_system_get_major_extension_table(uint16_t extension, uint16_t version_major, size_t table_length, void *table);
|
||||
hsa_status_t HSA_API
|
||||
hsa_iterate_agents(hsa_status_t (*callback)(hsa_agent_t agent, void *data),
|
||||
void *data);
|
||||
@@ -68,10 +72,13 @@ namespace HSA
|
||||
hsa_status_t HSA_API hsa_agent_get_exception_policies(hsa_agent_t agent,
|
||||
hsa_profile_t profile,
|
||||
uint16_t *mask);
|
||||
hsa_status_t HSA_API hsa_cache_get_info(hsa_cache_t cache, hsa_cache_info_t attribute, void *value);
|
||||
hsa_status_t HSA_API hsa_agent_iterate_caches(hsa_agent_t agent, hsa_status_t (*callback )(hsa_cache_t cache, void *data), void *value);
|
||||
hsa_status_t HSA_API
|
||||
hsa_agent_extension_supported(uint16_t extension, hsa_agent_t agent,
|
||||
uint16_t version_major,
|
||||
uint16_t version_minor, bool *result);
|
||||
hsa_status_t HSA_API hsa_agent_major_extension_supported(uint16_t extension, hsa_agent_t agent, uint16_t version_major, uint16_t *version_minor, bool *result);
|
||||
hsa_status_t HSA_API
|
||||
hsa_queue_create(hsa_agent_t agent, uint32_t size, hsa_queue_type_t type,
|
||||
void (*callback)(hsa_status_t status, hsa_queue_t *source,
|
||||
@@ -84,37 +91,37 @@ namespace HSA
|
||||
hsa_signal_t completion_signal, hsa_queue_t **queue);
|
||||
hsa_status_t HSA_API hsa_queue_destroy(hsa_queue_t *queue);
|
||||
hsa_status_t HSA_API hsa_queue_inactivate(hsa_queue_t *queue);
|
||||
uint64_t HSA_API hsa_queue_load_read_index_acquire(const hsa_queue_t *queue);
|
||||
uint64_t HSA_API hsa_queue_load_read_index_scacquire(const hsa_queue_t *queue);
|
||||
uint64_t HSA_API hsa_queue_load_read_index_relaxed(const hsa_queue_t *queue);
|
||||
uint64_t HSA_API hsa_queue_load_write_index_acquire(const hsa_queue_t *queue);
|
||||
uint64_t HSA_API hsa_queue_load_write_index_scacquire(const hsa_queue_t *queue);
|
||||
uint64_t HSA_API hsa_queue_load_write_index_relaxed(const hsa_queue_t *queue);
|
||||
void HSA_API hsa_queue_store_write_index_relaxed(const hsa_queue_t *queue,
|
||||
uint64_t value);
|
||||
void HSA_API hsa_queue_store_write_index_release(const hsa_queue_t *queue,
|
||||
void HSA_API hsa_queue_store_write_index_screlease(const hsa_queue_t *queue,
|
||||
uint64_t value);
|
||||
uint64_t HSA_API hsa_queue_cas_write_index_acq_rel(const hsa_queue_t *queue,
|
||||
uint64_t HSA_API hsa_queue_cas_write_index_scacq_screl(const hsa_queue_t *queue,
|
||||
uint64_t expected,
|
||||
uint64_t value);
|
||||
uint64_t HSA_API hsa_queue_cas_write_index_acquire(const hsa_queue_t *queue,
|
||||
uint64_t HSA_API hsa_queue_cas_write_index_scacquire(const hsa_queue_t *queue,
|
||||
uint64_t expected,
|
||||
uint64_t value);
|
||||
uint64_t HSA_API hsa_queue_cas_write_index_relaxed(const hsa_queue_t *queue,
|
||||
uint64_t expected,
|
||||
uint64_t value);
|
||||
uint64_t HSA_API hsa_queue_cas_write_index_release(const hsa_queue_t *queue,
|
||||
uint64_t HSA_API hsa_queue_cas_write_index_screlease(const hsa_queue_t *queue,
|
||||
uint64_t expected,
|
||||
uint64_t value);
|
||||
uint64_t HSA_API
|
||||
hsa_queue_add_write_index_acq_rel(const hsa_queue_t *queue, uint64_t value);
|
||||
hsa_queue_add_write_index_scacq_screl(const hsa_queue_t *queue, uint64_t value);
|
||||
uint64_t HSA_API
|
||||
hsa_queue_add_write_index_acquire(const hsa_queue_t *queue, uint64_t value);
|
||||
hsa_queue_add_write_index_scacquire(const hsa_queue_t *queue, uint64_t value);
|
||||
uint64_t HSA_API
|
||||
hsa_queue_add_write_index_relaxed(const hsa_queue_t *queue, uint64_t value);
|
||||
uint64_t HSA_API
|
||||
hsa_queue_add_write_index_release(const hsa_queue_t *queue, uint64_t value);
|
||||
hsa_queue_add_write_index_screlease(const hsa_queue_t *queue, uint64_t value);
|
||||
void HSA_API hsa_queue_store_read_index_relaxed(const hsa_queue_t *queue,
|
||||
uint64_t value);
|
||||
void HSA_API hsa_queue_store_read_index_release(const hsa_queue_t *queue,
|
||||
void HSA_API hsa_queue_store_read_index_screlease(const hsa_queue_t *queue,
|
||||
uint64_t value);
|
||||
hsa_status_t HSA_API hsa_agent_iterate_regions(
|
||||
hsa_agent_t agent,
|
||||
@@ -135,11 +142,13 @@ namespace HSA
|
||||
const hsa_agent_t *consumers, hsa_signal_t *signal);
|
||||
hsa_status_t HSA_API hsa_signal_destroy(hsa_signal_t signal);
|
||||
hsa_signal_value_t HSA_API hsa_signal_load_relaxed(hsa_signal_t signal);
|
||||
hsa_signal_value_t HSA_API hsa_signal_load_acquire(hsa_signal_t signal);
|
||||
hsa_signal_value_t HSA_API hsa_signal_load_scacquire(hsa_signal_t signal);
|
||||
void HSA_API
|
||||
hsa_signal_store_relaxed(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
void HSA_API
|
||||
hsa_signal_store_release(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
hsa_signal_store_screlease(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
void HSA_API hsa_signal_silent_store_relaxed(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
void HSA_API hsa_signal_silent_store_screlease(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
hsa_signal_value_t HSA_API
|
||||
hsa_signal_wait_relaxed(hsa_signal_t signal,
|
||||
hsa_signal_condition_t condition,
|
||||
@@ -147,195 +156,269 @@ namespace HSA
|
||||
uint64_t timeout_hint,
|
||||
hsa_wait_state_t wait_expectancy_hint);
|
||||
hsa_signal_value_t HSA_API
|
||||
hsa_signal_wait_acquire(hsa_signal_t signal,
|
||||
hsa_signal_wait_scacquire(hsa_signal_t signal,
|
||||
hsa_signal_condition_t condition,
|
||||
hsa_signal_value_t compare_value,
|
||||
uint64_t timeout_hint,
|
||||
hsa_wait_state_t wait_expectancy_hint);
|
||||
hsa_status_t HSA_API hsa_signal_group_create(uint32_t num_signals, const hsa_signal_t *signals, uint32_t num_consumers, const hsa_agent_t *consumers, hsa_signal_group_t *signal_group);
|
||||
hsa_status_t HSA_API hsa_signal_group_destroy(hsa_signal_group_t signal_group);
|
||||
hsa_status_t HSA_API hsa_signal_group_wait_any_scacquire(hsa_signal_group_t signal_group, const hsa_signal_condition_t *conditions, const hsa_signal_value_t *compare_values, hsa_wait_state_t wait_state_hint, hsa_signal_t *signal, hsa_signal_value_t *value);
|
||||
hsa_status_t HSA_API hsa_signal_group_wait_any_relaxed(hsa_signal_group_t signal_group, const hsa_signal_condition_t *conditions, const hsa_signal_value_t *compare_values, hsa_wait_state_t wait_state_hint, hsa_signal_t *signal, hsa_signal_value_t *value);
|
||||
void HSA_API
|
||||
hsa_signal_and_relaxed(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
void HSA_API
|
||||
hsa_signal_and_acquire(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
hsa_signal_and_scacquire(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
void HSA_API
|
||||
hsa_signal_and_release(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
hsa_signal_and_screlease(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
void HSA_API
|
||||
hsa_signal_and_acq_rel(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
hsa_signal_and_scacq_screl(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
void HSA_API
|
||||
hsa_signal_or_relaxed(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
void HSA_API
|
||||
hsa_signal_or_acquire(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
hsa_signal_or_scacquire(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
void HSA_API
|
||||
hsa_signal_or_release(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
hsa_signal_or_screlease(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
void HSA_API
|
||||
hsa_signal_or_acq_rel(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
hsa_signal_or_scacq_screl(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
void HSA_API
|
||||
hsa_signal_xor_relaxed(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
void HSA_API
|
||||
hsa_signal_xor_acquire(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
hsa_signal_xor_scacquire(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
void HSA_API
|
||||
hsa_signal_xor_release(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
hsa_signal_xor_screlease(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
void HSA_API
|
||||
hsa_signal_xor_acq_rel(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
hsa_signal_xor_scacq_screl(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
void HSA_API
|
||||
hsa_signal_add_relaxed(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
void HSA_API
|
||||
hsa_signal_add_acquire(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
hsa_signal_add_scacquire(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
void HSA_API
|
||||
hsa_signal_add_release(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
hsa_signal_add_screlease(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
void HSA_API
|
||||
hsa_signal_add_acq_rel(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
hsa_signal_add_scacq_screl(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
void HSA_API
|
||||
hsa_signal_subtract_relaxed(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
void HSA_API
|
||||
hsa_signal_subtract_acquire(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
hsa_signal_subtract_scacquire(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
void HSA_API
|
||||
hsa_signal_subtract_release(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
hsa_signal_subtract_screlease(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
void HSA_API
|
||||
hsa_signal_subtract_acq_rel(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
hsa_signal_subtract_scacq_screl(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
hsa_signal_value_t HSA_API
|
||||
hsa_signal_exchange_relaxed(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
hsa_signal_value_t HSA_API
|
||||
hsa_signal_exchange_acquire(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
hsa_signal_exchange_scacquire(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
hsa_signal_value_t HSA_API
|
||||
hsa_signal_exchange_release(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
hsa_signal_exchange_screlease(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
hsa_signal_value_t HSA_API
|
||||
hsa_signal_exchange_acq_rel(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
hsa_signal_exchange_scacq_screl(hsa_signal_t signal, hsa_signal_value_t value);
|
||||
hsa_signal_value_t HSA_API hsa_signal_cas_relaxed(hsa_signal_t signal,
|
||||
hsa_signal_value_t expected,
|
||||
hsa_signal_value_t value);
|
||||
hsa_signal_value_t HSA_API hsa_signal_cas_acquire(hsa_signal_t signal,
|
||||
hsa_signal_value_t HSA_API hsa_signal_cas_scacquire(hsa_signal_t signal,
|
||||
hsa_signal_value_t expected,
|
||||
hsa_signal_value_t value);
|
||||
hsa_signal_value_t HSA_API hsa_signal_cas_release(hsa_signal_t signal,
|
||||
hsa_signal_value_t HSA_API hsa_signal_cas_screlease(hsa_signal_t signal,
|
||||
hsa_signal_value_t expected,
|
||||
hsa_signal_value_t value);
|
||||
hsa_signal_value_t HSA_API hsa_signal_cas_acq_rel(hsa_signal_t signal,
|
||||
hsa_signal_value_t HSA_API hsa_signal_cas_scacq_screl(hsa_signal_t signal,
|
||||
hsa_signal_value_t expected,
|
||||
hsa_signal_value_t value);
|
||||
hsa_status_t hsa_isa_from_name(
|
||||
const char *name,
|
||||
hsa_isa_t *isa
|
||||
);
|
||||
hsa_status_t HSA_API hsa_isa_get_info(
|
||||
hsa_isa_t isa,
|
||||
hsa_isa_info_t attribute,
|
||||
uint32_t index,
|
||||
void *value
|
||||
);
|
||||
hsa_status_t hsa_isa_compatible(
|
||||
hsa_isa_t code_object_isa,
|
||||
hsa_isa_t agent_isa,
|
||||
bool *result
|
||||
);
|
||||
hsa_status_t HSA_API hsa_code_object_serialize(
|
||||
hsa_code_object_t code_object,
|
||||
hsa_status_t (*alloc_callback)(
|
||||
size_t size, hsa_callback_data_t data, void **address
|
||||
),
|
||||
hsa_callback_data_t callback_data,
|
||||
const char *options,
|
||||
void **serialized_code_object,
|
||||
size_t *serialized_code_object_size
|
||||
);
|
||||
hsa_status_t HSA_API hsa_code_object_deserialize(
|
||||
void *serialized_code_object,
|
||||
size_t serialized_code_object_size,
|
||||
const char *options,
|
||||
hsa_code_object_t *code_object
|
||||
);
|
||||
hsa_status_t HSA_API hsa_code_object_destroy(
|
||||
hsa_code_object_t code_object
|
||||
);
|
||||
hsa_status_t HSA_API hsa_code_object_get_info(
|
||||
hsa_code_object_t code_object,
|
||||
hsa_code_object_info_t attribute,
|
||||
void *value
|
||||
);
|
||||
hsa_status_t HSA_API hsa_code_object_get_symbol(
|
||||
hsa_code_object_t code_object,
|
||||
const char *symbol_name,
|
||||
hsa_code_symbol_t *symbol
|
||||
);
|
||||
hsa_status_t HSA_API hsa_code_symbol_get_info(
|
||||
hsa_code_symbol_t code_symbol,
|
||||
hsa_code_symbol_info_t attribute,
|
||||
void *value
|
||||
);
|
||||
hsa_status_t HSA_API hsa_code_object_iterate_symbols(
|
||||
hsa_code_object_t code_object,
|
||||
hsa_status_t (*callback)(
|
||||
hsa_code_object_t code_object, hsa_code_symbol_t symbol, void *data
|
||||
),
|
||||
void *data
|
||||
);
|
||||
hsa_status_t HSA_API hsa_executable_create(
|
||||
hsa_profile_t profile,
|
||||
hsa_executable_state_t executable_state,
|
||||
const char *options,
|
||||
hsa_executable_t *executable
|
||||
);
|
||||
hsa_status_t HSA_API hsa_executable_destroy(
|
||||
hsa_executable_t executable
|
||||
);
|
||||
hsa_status_t HSA_API hsa_executable_load_code_object(
|
||||
hsa_executable_t executable,
|
||||
hsa_agent_t agent,
|
||||
hsa_code_object_t code_object,
|
||||
const char *options
|
||||
);
|
||||
hsa_status_t HSA_API hsa_executable_freeze(
|
||||
hsa_executable_t executable,
|
||||
const char *options
|
||||
);
|
||||
hsa_status_t HSA_API hsa_executable_get_info(
|
||||
hsa_executable_t executable,
|
||||
hsa_executable_info_t attribute,
|
||||
void *value
|
||||
);
|
||||
hsa_status_t HSA_API hsa_executable_global_variable_define(
|
||||
hsa_executable_t executable,
|
||||
const char *variable_name,
|
||||
void *address
|
||||
);
|
||||
hsa_status_t HSA_API hsa_executable_agent_global_variable_define(
|
||||
hsa_executable_t executable,
|
||||
hsa_agent_t agent,
|
||||
const char *variable_name,
|
||||
void *address
|
||||
);
|
||||
hsa_status_t HSA_API hsa_executable_readonly_variable_define(
|
||||
hsa_executable_t executable,
|
||||
hsa_agent_t agent,
|
||||
const char *variable_name,
|
||||
void *address
|
||||
);
|
||||
hsa_status_t HSA_API hsa_executable_validate(
|
||||
hsa_executable_t executable,
|
||||
uint32_t *result
|
||||
);
|
||||
hsa_status_t HSA_API hsa_executable_get_symbol(
|
||||
hsa_executable_t executable,
|
||||
const char *module_name,
|
||||
const char *symbol_name,
|
||||
hsa_agent_t agent,
|
||||
int32_t call_convention,
|
||||
hsa_executable_symbol_t *symbol
|
||||
);
|
||||
hsa_status_t HSA_API hsa_executable_symbol_get_info(
|
||||
hsa_executable_symbol_t executable_symbol,
|
||||
hsa_executable_symbol_info_t attribute,
|
||||
void *value
|
||||
);
|
||||
hsa_status_t HSA_API hsa_executable_iterate_symbols(
|
||||
hsa_executable_t executable,
|
||||
hsa_status_t (*callback)(
|
||||
hsa_executable_t executable, hsa_executable_symbol_t symbol, void *data
|
||||
),
|
||||
void *data
|
||||
);
|
||||
hsa_status_t HSA_API
|
||||
hsa_status_string(hsa_status_t status, const char **status_string);
|
||||
|
||||
//===--- Instruction Set Architecture -----------------------------------===//
|
||||
|
||||
hsa_status_t HSA_API hsa_isa_from_name(
|
||||
const char *name,
|
||||
hsa_isa_t *isa);
|
||||
hsa_status_t HSA_API hsa_agent_iterate_isas(
|
||||
hsa_agent_t agent,
|
||||
hsa_status_t (*callback)(hsa_isa_t isa,
|
||||
void *data),
|
||||
void *data);
|
||||
/* deprecated */ hsa_status_t HSA_API hsa_isa_get_info(
|
||||
hsa_isa_t isa,
|
||||
hsa_isa_info_t attribute,
|
||||
uint32_t index,
|
||||
void *value);
|
||||
hsa_status_t HSA_API hsa_isa_get_info_alt(
|
||||
hsa_isa_t isa,
|
||||
hsa_isa_info_t attribute,
|
||||
void *value);
|
||||
hsa_status_t HSA_API hsa_isa_get_exception_policies(
|
||||
hsa_isa_t isa,
|
||||
hsa_profile_t profile,
|
||||
uint16_t *mask);
|
||||
hsa_status_t HSA_API hsa_isa_get_round_method(
|
||||
hsa_isa_t isa,
|
||||
hsa_fp_type_t fp_type,
|
||||
hsa_flush_mode_t flush_mode,
|
||||
hsa_round_method_t *round_method);
|
||||
hsa_status_t HSA_API hsa_wavefront_get_info(
|
||||
hsa_wavefront_t wavefront,
|
||||
hsa_wavefront_info_t attribute,
|
||||
void *value);
|
||||
hsa_status_t HSA_API hsa_isa_iterate_wavefronts(
|
||||
hsa_isa_t isa,
|
||||
hsa_status_t (*callback)(hsa_wavefront_t wavefront,
|
||||
void *data),
|
||||
void *data);
|
||||
/* deprecated */ hsa_status_t HSA_API hsa_isa_compatible(
|
||||
hsa_isa_t code_object_isa,
|
||||
hsa_isa_t agent_isa,
|
||||
bool *result);
|
||||
|
||||
//===--- Code Objects (deprecated) --------------------------------------===//
|
||||
|
||||
/* deprecated */ hsa_status_t HSA_API hsa_code_object_serialize(
|
||||
hsa_code_object_t code_object,
|
||||
hsa_status_t (*alloc_callback)(size_t size,
|
||||
hsa_callback_data_t data,
|
||||
void **address),
|
||||
hsa_callback_data_t callback_data,
|
||||
const char *options,
|
||||
void **serialized_code_object,
|
||||
size_t *serialized_code_object_size);
|
||||
/* deprecated */ hsa_status_t HSA_API hsa_code_object_deserialize(
|
||||
void *serialized_code_object,
|
||||
size_t serialized_code_object_size,
|
||||
const char *options,
|
||||
hsa_code_object_t *code_object);
|
||||
/* deprecated */ hsa_status_t HSA_API hsa_code_object_destroy(
|
||||
hsa_code_object_t code_object);
|
||||
/* deprecated */ hsa_status_t HSA_API hsa_code_object_get_info(
|
||||
hsa_code_object_t code_object,
|
||||
hsa_code_object_info_t attribute,
|
||||
void *value);
|
||||
/* deprecated */ hsa_status_t HSA_API hsa_code_object_get_symbol(
|
||||
hsa_code_object_t code_object,
|
||||
const char *symbol_name,
|
||||
hsa_code_symbol_t *symbol);
|
||||
/* deprecated */ hsa_status_t HSA_API hsa_code_object_get_symbol_from_name(
|
||||
hsa_code_object_t code_object,
|
||||
const char *module_name,
|
||||
const char *symbol_name,
|
||||
hsa_code_symbol_t *symbol);
|
||||
/* deprecated */ hsa_status_t HSA_API hsa_code_symbol_get_info(
|
||||
hsa_code_symbol_t code_symbol,
|
||||
hsa_code_symbol_info_t attribute,
|
||||
void *value);
|
||||
/* deprecated */ hsa_status_t HSA_API hsa_code_object_iterate_symbols(
|
||||
hsa_code_object_t code_object,
|
||||
hsa_status_t (*callback)(hsa_code_object_t code_object,
|
||||
hsa_code_symbol_t symbol,
|
||||
void *data),
|
||||
void *data);
|
||||
|
||||
//===--- Executable -----------------------------------------------------===//
|
||||
|
||||
hsa_status_t HSA_API hsa_code_object_reader_create_from_file(
|
||||
hsa_file_t file,
|
||||
hsa_code_object_reader_t *code_object_reader);
|
||||
hsa_status_t HSA_API hsa_code_object_reader_create_from_memory(
|
||||
const void *code_object,
|
||||
size_t size,
|
||||
hsa_code_object_reader_t *code_object_reader);
|
||||
hsa_status_t HSA_API hsa_code_object_reader_destroy(
|
||||
hsa_code_object_reader_t code_object_reader);
|
||||
/* deprecated */ hsa_status_t HSA_API hsa_executable_create(
|
||||
hsa_profile_t profile,
|
||||
hsa_executable_state_t executable_state,
|
||||
const char *options,
|
||||
hsa_executable_t *executable);
|
||||
hsa_status_t HSA_API hsa_executable_create_alt(
|
||||
hsa_profile_t profile,
|
||||
hsa_default_float_rounding_mode_t default_float_rounding_mode,
|
||||
const char *options,
|
||||
hsa_executable_t *executable);
|
||||
hsa_status_t HSA_API hsa_executable_destroy(
|
||||
hsa_executable_t executable);
|
||||
/* deprecated */ hsa_status_t HSA_API hsa_executable_load_code_object(
|
||||
hsa_executable_t executable,
|
||||
hsa_agent_t agent,
|
||||
hsa_code_object_t code_object,
|
||||
const char *options);
|
||||
hsa_status_t HSA_API hsa_executable_load_program_code_object(
|
||||
hsa_executable_t executable,
|
||||
hsa_code_object_reader_t code_object_reader,
|
||||
const char *options,
|
||||
hsa_loaded_code_object_t *loaded_code_object);
|
||||
hsa_status_t HSA_API hsa_executable_load_agent_code_object(
|
||||
hsa_executable_t executable,
|
||||
hsa_agent_t agent,
|
||||
hsa_code_object_reader_t code_object_reader,
|
||||
const char *options,
|
||||
hsa_loaded_code_object_t *loaded_code_object);
|
||||
hsa_status_t HSA_API hsa_executable_freeze(
|
||||
hsa_executable_t executable,
|
||||
const char *options);
|
||||
hsa_status_t HSA_API hsa_executable_get_info(
|
||||
hsa_executable_t executable,
|
||||
hsa_executable_info_t attribute,
|
||||
void *value);
|
||||
hsa_status_t HSA_API hsa_executable_global_variable_define(
|
||||
hsa_executable_t executable,
|
||||
const char *variable_name,
|
||||
void *address);
|
||||
hsa_status_t HSA_API hsa_executable_agent_global_variable_define(
|
||||
hsa_executable_t executable,
|
||||
hsa_agent_t agent,
|
||||
const char *variable_name,
|
||||
void *address);
|
||||
hsa_status_t HSA_API hsa_executable_readonly_variable_define(
|
||||
hsa_executable_t executable,
|
||||
hsa_agent_t agent,
|
||||
const char *variable_name,
|
||||
void *address);
|
||||
hsa_status_t HSA_API hsa_executable_validate(
|
||||
hsa_executable_t executable,
|
||||
uint32_t *result);
|
||||
hsa_status_t HSA_API hsa_executable_validate_alt(
|
||||
hsa_executable_t executable,
|
||||
const char *options,
|
||||
uint32_t *result);
|
||||
/* deprecated */ hsa_status_t HSA_API hsa_executable_get_symbol(
|
||||
hsa_executable_t executable,
|
||||
const char *module_name,
|
||||
const char *symbol_name,
|
||||
hsa_agent_t agent,
|
||||
int32_t call_convention,
|
||||
hsa_executable_symbol_t *symbol);
|
||||
hsa_status_t HSA_API hsa_executable_get_symbol_by_name(
|
||||
hsa_executable_t executable,
|
||||
const char *symbol_name,
|
||||
const hsa_agent_t *agent,
|
||||
hsa_executable_symbol_t *symbol);
|
||||
hsa_status_t HSA_API hsa_executable_symbol_get_info(
|
||||
hsa_executable_symbol_t executable_symbol,
|
||||
hsa_executable_symbol_info_t attribute,
|
||||
void *value);
|
||||
/* deprecated */ hsa_status_t HSA_API hsa_executable_iterate_symbols(
|
||||
hsa_executable_t executable,
|
||||
hsa_status_t (*callback)(hsa_executable_t executable,
|
||||
hsa_executable_symbol_t symbol,
|
||||
void *data),
|
||||
void *data);
|
||||
hsa_status_t HSA_API hsa_executable_iterate_agent_symbols(
|
||||
hsa_executable_t executable,
|
||||
hsa_agent_t agent,
|
||||
hsa_status_t (*callback)(hsa_executable_t exec,
|
||||
hsa_agent_t agent,
|
||||
hsa_executable_symbol_t symbol,
|
||||
void *data),
|
||||
void *data);
|
||||
hsa_status_t HSA_API hsa_executable_iterate_program_symbols(
|
||||
hsa_executable_t executable,
|
||||
hsa_status_t (*callback)(hsa_executable_t exec,
|
||||
hsa_executable_symbol_t symbol,
|
||||
void *data),
|
||||
void *data);
|
||||
|
||||
//===--- Runtime Notifications ------------------------------------------===//
|
||||
|
||||
hsa_status_t HSA_API hsa_status_string(
|
||||
hsa_status_t status,
|
||||
const char **status_string);
|
||||
}
|
||||
|
||||
#ifdef BUILDING_HSA_CORE_RUNTIME
|
||||
|
||||
@@ -52,6 +52,35 @@
|
||||
|
||||
namespace core {
|
||||
|
||||
/// @class Wavefront.
|
||||
/// @brief Wavefront.
|
||||
class Wavefront final: public amd::hsa::common::Signed<0xA02483F1AD7F101C> {
|
||||
public:
|
||||
/// @brief Default destructor.
|
||||
~Wavefront() {}
|
||||
|
||||
/// @returns Handle equivalent of @p object.
|
||||
static hsa_wavefront_t Handle(const Wavefront *object) {
|
||||
hsa_wavefront_t handle = { reinterpret_cast<uint64_t>(object) };
|
||||
return handle;
|
||||
}
|
||||
/// @returns Object equivalent of @p handle.
|
||||
static Wavefront *Object(const hsa_wavefront_t &handle) {
|
||||
Wavefront *object = amd::hsa::common::ObjectAt<Wavefront>(handle.handle);
|
||||
return object;
|
||||
}
|
||||
|
||||
/// @brief Query value of requested @p attribute and record it in @p value.
|
||||
bool GetInfo(const hsa_wavefront_info_t &attribute, void *value) const;
|
||||
|
||||
private:
|
||||
/// @brief Default constructor.
|
||||
Wavefront() {}
|
||||
|
||||
/// @brief Wavefront's friends.
|
||||
friend class Isa;
|
||||
};
|
||||
|
||||
/// @class Isa.
|
||||
/// @brief Instruction Set Architecture.
|
||||
class Isa final: public amd::hsa::common::Signed<0xB13594F2BD8F212D> {
|
||||
@@ -67,7 +96,7 @@ class Isa final: public amd::hsa::common::Signed<0xB13594F2BD8F212D> {
|
||||
hsa_isa_t isa_handle = { reinterpret_cast<uint64_t>(isa_object) };
|
||||
return isa_handle;
|
||||
}
|
||||
/// @returns Object equivalend of @p isa_handle.
|
||||
/// @returns Object equivalent of @p isa_handle.
|
||||
static Isa *Object(const hsa_isa_t &isa_handle) {
|
||||
Isa *isa_object = amd::hsa::common::ObjectAt<Isa>(isa_handle.handle);
|
||||
return isa_object;
|
||||
@@ -77,6 +106,10 @@ class Isa final: public amd::hsa::common::Signed<0xB13594F2BD8F212D> {
|
||||
const Version &version() const {
|
||||
return version_;
|
||||
}
|
||||
/// @returns This Isa's supported wavefront.
|
||||
const Wavefront &wavefront() const {
|
||||
return wavefront_;
|
||||
}
|
||||
|
||||
/// @returns This Isa's vendor.
|
||||
std::string GetVendor() const {
|
||||
@@ -98,6 +131,10 @@ class Isa final: public amd::hsa::common::Signed<0xB13594F2BD8F212D> {
|
||||
int32_t GetStepping() const {
|
||||
return std::get<2>(version_);
|
||||
}
|
||||
/// @returns Pointer to this Isa's supported wavefront.
|
||||
const Wavefront *GetWavefront() const {
|
||||
return &wavefront_;
|
||||
}
|
||||
|
||||
/// @returns True if this Isa is compatible with @p isa_object, false
|
||||
/// otherwise.
|
||||
@@ -122,6 +159,13 @@ class Isa final: public amd::hsa::common::Signed<0xB13594F2BD8F212D> {
|
||||
/// @brief Query value of requested @p attribute and record it in @p value.
|
||||
bool GetInfo(const hsa_isa_info_t &attribute, void *value) const;
|
||||
|
||||
/// @returns Round method (single or double) used to implement the floating-
|
||||
/// point multiply add instruction (mad) for a given combination of @p fp_type
|
||||
/// and @p flush_mode.
|
||||
hsa_round_method_t GetRoundMethod(
|
||||
hsa_fp_type_t fp_type,
|
||||
hsa_flush_mode_t flush_mode) const;
|
||||
|
||||
private:
|
||||
/// @brief Default constructor.
|
||||
Isa(): version_(Version(-1, -1, -1)) {}
|
||||
@@ -132,6 +176,9 @@ class Isa final: public amd::hsa::common::Signed<0xB13594F2BD8F212D> {
|
||||
/// @brief Isa's version.
|
||||
Version version_;
|
||||
|
||||
/// @brief Isa's supported wavefront.
|
||||
Wavefront wavefront_;
|
||||
|
||||
/// @brief Isa's friends.
|
||||
friend class IsaRegistry;
|
||||
}; // class Isa
|
||||
|
||||
@@ -90,11 +90,11 @@ struct AqlPacket {
|
||||
<< "\nbarrier: " << ((dispatch.header >> HSA_PACKET_HEADER_BARRIER) &
|
||||
((1 << HSA_PACKET_HEADER_WIDTH_BARRIER) - 1))
|
||||
<< "\nacquire: "
|
||||
<< ((dispatch.header >> HSA_PACKET_HEADER_ACQUIRE_FENCE_SCOPE) &
|
||||
((1 << HSA_PACKET_HEADER_WIDTH_ACQUIRE_FENCE_SCOPE) - 1))
|
||||
<< ((dispatch.header >> HSA_PACKET_HEADER_SCACQUIRE_FENCE_SCOPE) &
|
||||
((1 << HSA_PACKET_HEADER_WIDTH_SCACQUIRE_FENCE_SCOPE) - 1))
|
||||
<< "\nrelease: "
|
||||
<< ((dispatch.header >> HSA_PACKET_HEADER_RELEASE_FENCE_SCOPE) &
|
||||
((1 << HSA_PACKET_HEADER_WIDTH_RELEASE_FENCE_SCOPE) - 1));
|
||||
<< ((dispatch.header >> HSA_PACKET_HEADER_SCRELEASE_FENCE_SCOPE) &
|
||||
((1 << HSA_PACKET_HEADER_WIDTH_SCRELEASE_FENCE_SCOPE) - 1));
|
||||
|
||||
if (type == HSA_PACKET_TYPE_KERNEL_DISPATCH) {
|
||||
string << "\nDim: " << dispatch.setup
|
||||
|
||||
@@ -209,9 +209,9 @@ class Signal : public Checked<0x71FCCA6A3D5D5276>,
|
||||
/// timeout is reached.
|
||||
/// Returns the index of a satisfied signal. Returns -1 on timeout and
|
||||
/// errors.
|
||||
static uint32_t WaitAny(uint32_t signal_count, hsa_signal_t* hsa_signals,
|
||||
hsa_signal_condition_t* conds,
|
||||
hsa_signal_value_t* values, uint64_t timeout_hint,
|
||||
static uint32_t WaitAny(uint32_t signal_count, const hsa_signal_t* hsa_signals,
|
||||
const hsa_signal_condition_t* conds,
|
||||
const hsa_signal_value_t* values, uint64_t timeout_hint,
|
||||
hsa_wait_state_t wait_hint,
|
||||
hsa_signal_value_t* satisfying_value);
|
||||
|
||||
@@ -277,5 +277,28 @@ static_assert(
|
||||
sizeof(hsa_signal_handle[2]) == sizeof(hsa_signal_t[2]),
|
||||
"hsa_signal_handle and hsa_signal_t must have identical binary layout.");
|
||||
|
||||
class SignalGroup : public Checked<0xBD35DDDD578F091>
|
||||
{
|
||||
public:
|
||||
static __forceinline hsa_signal_group_t Convert(SignalGroup* group) { const hsa_signal_group_t handle = { static_cast<uint64_t>(reinterpret_cast<uintptr_t>(group)) }; return handle; }
|
||||
static __forceinline SignalGroup* Convert(hsa_signal_group_t group) { return reinterpret_cast<SignalGroup*>(static_cast<uintptr_t>(group.handle)); }
|
||||
|
||||
SignalGroup(uint32_t num_signals, const hsa_signal_t* signals);
|
||||
~SignalGroup() { delete[] signals; }
|
||||
|
||||
bool IsValid() const {
|
||||
if (CheckedType::IsValid() && signals!=NULL) return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
const hsa_signal_t* List() const { return signals; }
|
||||
uint32_t Count() const { return count; }
|
||||
|
||||
private:
|
||||
hsa_signal_t* signals;
|
||||
const uint32_t count;
|
||||
DISALLOW_COPY_AND_ASSIGN(SignalGroup);
|
||||
};
|
||||
|
||||
} // namespace core
|
||||
#endif // header guard
|
||||
|
||||
@@ -603,7 +603,7 @@ hsa_status_t BlitKernel::SubmitLinearCopyCommand(void* dst, const void* src,
|
||||
}
|
||||
|
||||
// Wait for the packet to finish.
|
||||
if (HSA::hsa_signal_wait_acquire(completion_signal_, HSA_SIGNAL_CONDITION_LT,
|
||||
if (HSA::hsa_signal_wait_scacquire(completion_signal_, HSA_SIGNAL_CONDITION_LT,
|
||||
1, uint64_t(-1),
|
||||
HSA_WAIT_STATE_ACTIVE) != 0) {
|
||||
// Signal wait returned unexpected value.
|
||||
@@ -627,8 +627,8 @@ hsa_status_t BlitKernel::SubmitLinearCopyCommand(
|
||||
const uint16_t kBarrierPacketHeader =
|
||||
(HSA_PACKET_TYPE_BARRIER_AND << HSA_PACKET_HEADER_TYPE) |
|
||||
(1 << HSA_PACKET_HEADER_BARRIER) |
|
||||
(HSA_FENCE_SCOPE_NONE << HSA_PACKET_HEADER_ACQUIRE_FENCE_SCOPE) |
|
||||
(HSA_FENCE_SCOPE_AGENT << HSA_PACKET_HEADER_RELEASE_FENCE_SCOPE);
|
||||
(HSA_FENCE_SCOPE_NONE << HSA_PACKET_HEADER_SCACQUIRE_FENCE_SCOPE) |
|
||||
(HSA_FENCE_SCOPE_AGENT << HSA_PACKET_HEADER_SCRELEASE_FENCE_SCOPE);
|
||||
|
||||
hsa_barrier_and_packet_t barrier_packet = {0};
|
||||
barrier_packet.header = HSA_PACKET_TYPE_INVALID;
|
||||
@@ -766,7 +766,7 @@ hsa_status_t BlitKernel::SubmitLinearFillCommand(void* ptr, uint32_t value,
|
||||
ReleaseWriteIndex(write_index, 1);
|
||||
|
||||
// Wait for the packet to finish.
|
||||
if (HSA::hsa_signal_wait_acquire(completion_signal_, HSA_SIGNAL_CONDITION_LT,
|
||||
if (HSA::hsa_signal_wait_scacquire(completion_signal_, HSA_SIGNAL_CONDITION_LT,
|
||||
1, uint64_t(-1),
|
||||
HSA_WAIT_STATE_ACTIVE) != 0) {
|
||||
// Signal wait returned unexpected value.
|
||||
@@ -813,8 +813,8 @@ hsa_status_t BlitKernel::FenceRelease(uint64_t write_index,
|
||||
const uint16_t kBarrierPacketHeader =
|
||||
(HSA_PACKET_TYPE_BARRIER_AND << HSA_PACKET_HEADER_TYPE) |
|
||||
(1 << HSA_PACKET_HEADER_BARRIER) |
|
||||
(HSA_FENCE_SCOPE_NONE << HSA_PACKET_HEADER_ACQUIRE_FENCE_SCOPE) |
|
||||
(fence << HSA_PACKET_HEADER_RELEASE_FENCE_SCOPE);
|
||||
(HSA_FENCE_SCOPE_NONE << HSA_PACKET_HEADER_SCACQUIRE_FENCE_SCOPE) |
|
||||
(fence << HSA_PACKET_HEADER_SCRELEASE_FENCE_SCOPE);
|
||||
|
||||
hsa_barrier_and_packet_t packet = {0};
|
||||
packet.header = kInvalidPacketHeader;
|
||||
@@ -842,7 +842,7 @@ hsa_status_t BlitKernel::FenceRelease(uint64_t write_index,
|
||||
ReleaseWriteIndex(write_index, num_copy_packet + 1);
|
||||
|
||||
// Wait for the packet to finish.
|
||||
if (HSA::hsa_signal_wait_acquire(packet.completion_signal,
|
||||
if (HSA::hsa_signal_wait_scacquire(packet.completion_signal,
|
||||
HSA_SIGNAL_CONDITION_LT, 1, uint64_t(-1),
|
||||
HSA_WAIT_STATE_ACTIVE) != 0) {
|
||||
// Signal wait returned unexpected value.
|
||||
@@ -862,8 +862,8 @@ void BlitKernel::PopulateQueue(uint64_t index, uint64_t code_handle, void* args,
|
||||
static const uint16_t kDispatchPacketHeader =
|
||||
(HSA_PACKET_TYPE_KERNEL_DISPATCH << HSA_PACKET_HEADER_TYPE) |
|
||||
(((completion_signal.handle != 0) ? 1 : 0) << HSA_PACKET_HEADER_BARRIER) |
|
||||
(HSA_FENCE_SCOPE_SYSTEM << HSA_PACKET_HEADER_ACQUIRE_FENCE_SCOPE) |
|
||||
(HSA_FENCE_SCOPE_SYSTEM << HSA_PACKET_HEADER_RELEASE_FENCE_SCOPE);
|
||||
(HSA_FENCE_SCOPE_SYSTEM << HSA_PACKET_HEADER_SCACQUIRE_FENCE_SCOPE) |
|
||||
(HSA_FENCE_SCOPE_SYSTEM << HSA_PACKET_HEADER_SCRELEASE_FENCE_SCOPE);
|
||||
|
||||
packet.header = kInvalidPacketHeader;
|
||||
packet.kernel_object = code_handle;
|
||||
|
||||
@@ -125,6 +125,15 @@ void CpuAgent::InitCacheList() {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//Update cache objects
|
||||
caches_.clear();
|
||||
caches_.resize(cache_props_.size());
|
||||
char name[64];
|
||||
GetInfo(HSA_AGENT_INFO_NAME, name);
|
||||
std::string deviceName=name;
|
||||
for(size_t i=0; i<caches_.size(); i++)
|
||||
caches_[i].reset(new core::Cache(deviceName+" L"+std::to_string(cache_props_[i].CacheLevel), cache_props_[i].CacheLevel, cache_props_[i].CacheSize));
|
||||
}
|
||||
|
||||
hsa_status_t CpuAgent::VisitRegion(bool include_peer,
|
||||
@@ -167,6 +176,17 @@ hsa_status_t CpuAgent::IterateRegion(
|
||||
return VisitRegion(true, callback, data);
|
||||
}
|
||||
|
||||
hsa_status_t CpuAgent::IterateCache(hsa_status_t (*callback )(hsa_cache_t cache, void *data), void* data) const
|
||||
{
|
||||
for(size_t i=0; i<caches_.size(); i++)
|
||||
{
|
||||
hsa_status_t stat = callback(core::Cache::Convert(caches_[i].get()), data);
|
||||
if(stat!=HSA_STATUS_SUCCESS)
|
||||
return stat;
|
||||
}
|
||||
return HSA_STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
hsa_status_t CpuAgent::GetInfo(hsa_agent_info_t attribute, void* value) const {
|
||||
const size_t kNameSize = 64; // agent, and vendor name size limit
|
||||
|
||||
@@ -263,7 +283,7 @@ hsa_status_t CpuAgent::GetInfo(hsa_agent_info_t attribute, void* value) const {
|
||||
*((uint16_t*)value) = 1;
|
||||
break;
|
||||
case HSA_AGENT_INFO_VERSION_MINOR:
|
||||
*((uint16_t*)value) = 0;
|
||||
*((uint16_t*)value) = 1;
|
||||
break;
|
||||
case HSA_EXT_AGENT_INFO_IMAGE_1D_MAX_ELEMENTS:
|
||||
case HSA_EXT_AGENT_INFO_IMAGE_1DA_MAX_ELEMENTS:
|
||||
|
||||
@@ -377,6 +377,15 @@ void GpuAgent::InitCacheList() {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//Update cache objects
|
||||
caches_.clear();
|
||||
caches_.resize(cache_props_.size());
|
||||
char name[64];
|
||||
GetInfo(HSA_AGENT_INFO_NAME, name);
|
||||
std::string deviceName=name;
|
||||
for(size_t i=0; i<caches_.size(); i++)
|
||||
caches_[i].reset(new core::Cache(deviceName+" L"+std::to_string(cache_props_[i].CacheLevel), cache_props_[i].CacheLevel, cache_props_[i].CacheSize));
|
||||
}
|
||||
|
||||
bool GpuAgent::InitEndTsPool() {
|
||||
@@ -436,6 +445,17 @@ hsa_status_t GpuAgent::IterateRegion(
|
||||
return VisitRegion(true, callback, data);
|
||||
}
|
||||
|
||||
hsa_status_t GpuAgent::IterateCache(hsa_status_t (*callback )(hsa_cache_t cache, void *data), void* data) const
|
||||
{
|
||||
for(size_t i=0; i<caches_.size(); i++)
|
||||
{
|
||||
hsa_status_t stat = callback(core::Cache::Convert(caches_[i].get()), data);
|
||||
if(stat!=HSA_STATUS_SUCCESS)
|
||||
return stat;
|
||||
}
|
||||
return HSA_STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
hsa_status_t GpuAgent::VisitRegion(bool include_peer,
|
||||
hsa_status_t (*callback)(hsa_region_t region,
|
||||
void* data),
|
||||
@@ -738,24 +758,28 @@ hsa_status_t GpuAgent::GetInfo(hsa_agent_info_t attribute, void* value) const {
|
||||
*((hsa_isa_t*)value) = core::Isa::Handle(isa_);
|
||||
break;
|
||||
case HSA_AGENT_INFO_EXTENSIONS:
|
||||
memset(value, 0, sizeof(uint8_t) * 128);
|
||||
{
|
||||
memset(value, 0, sizeof(uint8_t) * 128);
|
||||
|
||||
if (core::hsa_internal_api_table_.finalizer_api.hsa_ext_program_finalize_fn != NULL) {
|
||||
*((uint8_t*)value) = 1 << HSA_EXTENSION_FINALIZER;
|
||||
auto setFlag = [&](uint32_t bit) { assert(bit<128*8 && "Extension value exceeds extension bitmask"); uint index = bit/8; uint subBit = bit%8; ((uint8_t*)value)[index] |= 1<<subBit; };
|
||||
|
||||
if (core::hsa_internal_api_table_.finalizer_api.hsa_ext_program_finalize_fn != NULL) {
|
||||
setFlag(HSA_EXTENSION_FINALIZER);
|
||||
}
|
||||
|
||||
if (core::hsa_internal_api_table_.image_api.hsa_ext_image_create_fn != NULL) {
|
||||
setFlag(HSA_EXTENSION_IMAGES);
|
||||
}
|
||||
|
||||
setFlag(HSA_EXTENSION_AMD_PROFILER);
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
if (core::hsa_internal_api_table_.image_api.hsa_ext_image_create_fn != NULL) {
|
||||
*((uint8_t*)value) |= 1 << HSA_EXTENSION_IMAGES;
|
||||
}
|
||||
|
||||
*((uint8_t*)value) |= 1 << HSA_EXTENSION_AMD_PROFILER;
|
||||
|
||||
break;
|
||||
case HSA_AGENT_INFO_VERSION_MAJOR:
|
||||
*((uint16_t*)value) = 1;
|
||||
break;
|
||||
case HSA_AGENT_INFO_VERSION_MINOR:
|
||||
*((uint16_t*)value) = 0;
|
||||
*((uint16_t*)value) = 1;
|
||||
break;
|
||||
case HSA_EXT_AGENT_INFO_IMAGE_1D_MAX_ELEMENTS:
|
||||
case HSA_EXT_AGENT_INFO_IMAGE_1DA_MAX_ELEMENTS:
|
||||
|
||||
+46
-33
@@ -370,6 +370,26 @@ bool RegionMemory::Freeze() {
|
||||
return true;
|
||||
}
|
||||
|
||||
hsa_status_t IsIsaEquivalent(hsa_isa_t isa, void *data) {
|
||||
assert(data);
|
||||
|
||||
std::pair<hsa_isa_t, bool> *data_pair = (std::pair<hsa_isa_t, bool>*)data;
|
||||
assert(data_pair);
|
||||
assert(data_pair->first.handle != 0);
|
||||
assert(data_pair->second != true);
|
||||
|
||||
const core::Isa *isa1 = core::Isa::Object(isa);
|
||||
assert(isa1);
|
||||
const core::Isa *isa2 = core::Isa::Object(data_pair->first);
|
||||
assert(isa2);
|
||||
if (isa1->version() == isa2->version()) {
|
||||
data_pair->second = true;
|
||||
return HSA_STATUS_INFO_BREAK;
|
||||
}
|
||||
|
||||
return HSA_STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
} // namespace anonymous
|
||||
|
||||
namespace amd {
|
||||
@@ -392,25 +412,14 @@ hsa_isa_t LoaderContext::IsaFromName(const char *name) {
|
||||
|
||||
bool LoaderContext::IsaSupportedByAgent(hsa_agent_t agent,
|
||||
hsa_isa_t code_object_isa) {
|
||||
assert(agent.handle);
|
||||
assert(agent.handle != 0);
|
||||
|
||||
hsa_status_t hsa_status = HSA_STATUS_SUCCESS;
|
||||
hsa_isa_t agent_isa;
|
||||
agent_isa.handle = 0;
|
||||
|
||||
hsa_status = HSA::hsa_agent_get_info(agent, HSA_AGENT_INFO_ISA, &agent_isa);
|
||||
if (HSA_STATUS_SUCCESS != hsa_status) {
|
||||
std::pair<hsa_isa_t, bool> data(code_object_isa, false);
|
||||
hsa_status_t status = HSA::hsa_agent_iterate_isas(agent, IsIsaEquivalent, &data);
|
||||
if (status != HSA_STATUS_SUCCESS && status != HSA_STATUS_INFO_BREAK) {
|
||||
return false;
|
||||
}
|
||||
|
||||
bool result = false;
|
||||
|
||||
hsa_status = HSA::hsa_isa_compatible(code_object_isa, agent_isa, &result);
|
||||
if (HSA_STATUS_SUCCESS != hsa_status) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return result;
|
||||
return data.second;
|
||||
}
|
||||
|
||||
void* LoaderContext::SegmentAlloc(amdgpu_hsa_elf_segment_t segment,
|
||||
@@ -421,14 +430,16 @@ void* LoaderContext::SegmentAlloc(amdgpu_hsa_elf_segment_t segment,
|
||||
{
|
||||
assert(0 < size);
|
||||
assert(0 < align && 0 == (align & (align - 1)));
|
||||
hsa_profile_t agent_profile;
|
||||
if (HSA_STATUS_SUCCESS != HSA::hsa_agent_get_info(agent, HSA_AGENT_INFO_PROFILE, &agent_profile)) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
SegmentMemory *mem = nullptr;
|
||||
switch (segment) {
|
||||
case AMDGPU_HSA_SEGMENT_GLOBAL_AGENT:
|
||||
case AMDGPU_HSA_SEGMENT_READONLY_AGENT:
|
||||
case AMDGPU_HSA_SEGMENT_READONLY_AGENT: {
|
||||
hsa_profile_t agent_profile;
|
||||
if (HSA_STATUS_SUCCESS != HSA::hsa_agent_get_info(agent, HSA_AGENT_INFO_PROFILE, &agent_profile)) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
switch (agent_profile) {
|
||||
case HSA_PROFILE_BASE:
|
||||
mem = new (std::nothrow) RegionMemory(RegionMemory::AgentLocal(agent));
|
||||
@@ -440,19 +451,17 @@ void* LoaderContext::SegmentAlloc(amdgpu_hsa_elf_segment_t segment,
|
||||
assert(false);
|
||||
}
|
||||
break;
|
||||
case AMDGPU_HSA_SEGMENT_GLOBAL_PROGRAM:
|
||||
switch (agent_profile) {
|
||||
case HSA_PROFILE_BASE:
|
||||
mem = new (std::nothrow) RegionMemory(RegionMemory::System());
|
||||
break;
|
||||
case HSA_PROFILE_FULL:
|
||||
mem = new (std::nothrow) MallocedMemory();
|
||||
break;
|
||||
default:
|
||||
assert(false);
|
||||
}
|
||||
}
|
||||
case AMDGPU_HSA_SEGMENT_GLOBAL_PROGRAM: {
|
||||
mem = new (std::nothrow) RegionMemory(RegionMemory::System());
|
||||
break;
|
||||
case AMDGPU_HSA_SEGMENT_CODE_AGENT:
|
||||
}
|
||||
case AMDGPU_HSA_SEGMENT_CODE_AGENT: {
|
||||
hsa_profile_t agent_profile;
|
||||
if (HSA_STATUS_SUCCESS != HSA::hsa_agent_get_info(agent, HSA_AGENT_INFO_PROFILE, &agent_profile)) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
switch (agent_profile) {
|
||||
case HSA_PROFILE_BASE:
|
||||
mem = new (std::nothrow) RegionMemory(IsDebuggerRegistered() ?
|
||||
@@ -470,16 +479,20 @@ void* LoaderContext::SegmentAlloc(amdgpu_hsa_elf_segment_t segment,
|
||||
((GpuAgentInt*)core::Agent::Convert(agent))->InvalidateCodeCaches();
|
||||
|
||||
break;
|
||||
}
|
||||
default:
|
||||
assert(false);
|
||||
}
|
||||
|
||||
if (nullptr == mem) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
if (!mem->Allocate(size, align, zero)) {
|
||||
delete mem;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
return mem;
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,71 @@
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// The University of Illinois/NCSA
|
||||
// Open Source License (NCSA)
|
||||
//
|
||||
// Copyright (c) 2014-2015, Advanced Micro Devices, Inc. All rights reserved.
|
||||
//
|
||||
// Developed by:
|
||||
//
|
||||
// AMD Research and AMD HSA Software Development
|
||||
//
|
||||
// Advanced Micro Devices, Inc.
|
||||
//
|
||||
// www.amd.com
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
// of this software and associated documentation files (the "Software"), to
|
||||
// deal with the Software without restriction, including without limitation
|
||||
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
// and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// - Redistributions of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimers.
|
||||
// - Redistributions in binary form must reproduce the above copyright
|
||||
// notice, this list of conditions and the following disclaimers in
|
||||
// the documentation and/or other materials provided with the distribution.
|
||||
// - Neither the names of Advanced Micro Devices, Inc,
|
||||
// nor the names of its contributors may be used to endorse or promote
|
||||
// products derived from this Software without specific prior written
|
||||
// permission.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
||||
// THE CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
||||
// OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||
// DEALINGS WITH THE SOFTWARE.
|
||||
//
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include "core/inc/cache.h"
|
||||
#include "assert.h"
|
||||
|
||||
namespace core
|
||||
{
|
||||
|
||||
hsa_status_t Cache::GetInfo(hsa_cache_info_t attribute, void* value)
|
||||
{
|
||||
switch(attribute)
|
||||
{
|
||||
case HSA_CACHE_INFO_NAME_LENGTH:
|
||||
*(uint32_t*)value=name_.size();
|
||||
break;
|
||||
case HSA_CACHE_INFO_NAME:
|
||||
*(const char**)value=name_.c_str();
|
||||
break;
|
||||
case HSA_CACHE_INFO_LEVEL:
|
||||
*(uint8_t*)value=level_;
|
||||
break;
|
||||
case HSA_CACHE_INFO_SIZE:
|
||||
*(uint32_t*)value=size_;
|
||||
break;
|
||||
default:
|
||||
return HSA_STATUS_ERROR_INVALID_ARGUMENT;
|
||||
}
|
||||
return HSA_STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
}
|
||||
Fichier diff supprimé car celui-ci est trop grand
Voir la Diff
@@ -146,38 +146,38 @@ void HsaApiTable::UpdateCore() {
|
||||
core_api.hsa_soft_queue_create_fn = HSA::hsa_soft_queue_create;
|
||||
core_api.hsa_queue_destroy_fn = HSA::hsa_queue_destroy;
|
||||
core_api.hsa_queue_inactivate_fn = HSA::hsa_queue_inactivate;
|
||||
core_api.hsa_queue_load_read_index_acquire_fn =
|
||||
HSA::hsa_queue_load_read_index_acquire;
|
||||
core_api.hsa_queue_load_read_index_scacquire_fn =
|
||||
HSA::hsa_queue_load_read_index_scacquire;
|
||||
core_api.hsa_queue_load_read_index_relaxed_fn =
|
||||
HSA::hsa_queue_load_read_index_relaxed;
|
||||
core_api.hsa_queue_load_write_index_acquire_fn =
|
||||
HSA::hsa_queue_load_write_index_acquire;
|
||||
core_api.hsa_queue_load_write_index_scacquire_fn =
|
||||
HSA::hsa_queue_load_write_index_scacquire;
|
||||
core_api.hsa_queue_load_write_index_relaxed_fn =
|
||||
HSA::hsa_queue_load_write_index_relaxed;
|
||||
core_api.hsa_queue_store_write_index_relaxed_fn =
|
||||
HSA::hsa_queue_store_write_index_relaxed;
|
||||
core_api.hsa_queue_store_write_index_release_fn =
|
||||
HSA::hsa_queue_store_write_index_release;
|
||||
core_api.hsa_queue_cas_write_index_acq_rel_fn =
|
||||
HSA::hsa_queue_cas_write_index_acq_rel;
|
||||
core_api.hsa_queue_cas_write_index_acquire_fn =
|
||||
HSA::hsa_queue_cas_write_index_acquire;
|
||||
core_api.hsa_queue_store_write_index_screlease_fn =
|
||||
HSA::hsa_queue_store_write_index_screlease;
|
||||
core_api.hsa_queue_cas_write_index_scacq_screl_fn =
|
||||
HSA::hsa_queue_cas_write_index_scacq_screl;
|
||||
core_api.hsa_queue_cas_write_index_scacquire_fn =
|
||||
HSA::hsa_queue_cas_write_index_scacquire;
|
||||
core_api.hsa_queue_cas_write_index_relaxed_fn =
|
||||
HSA::hsa_queue_cas_write_index_relaxed;
|
||||
core_api.hsa_queue_cas_write_index_release_fn =
|
||||
HSA::hsa_queue_cas_write_index_release;
|
||||
core_api.hsa_queue_add_write_index_acq_rel_fn =
|
||||
HSA::hsa_queue_add_write_index_acq_rel;
|
||||
core_api.hsa_queue_add_write_index_acquire_fn =
|
||||
HSA::hsa_queue_add_write_index_acquire;
|
||||
core_api.hsa_queue_cas_write_index_screlease_fn =
|
||||
HSA::hsa_queue_cas_write_index_screlease;
|
||||
core_api.hsa_queue_add_write_index_scacq_screl_fn =
|
||||
HSA::hsa_queue_add_write_index_scacq_screl;
|
||||
core_api.hsa_queue_add_write_index_scacquire_fn =
|
||||
HSA::hsa_queue_add_write_index_scacquire;
|
||||
core_api.hsa_queue_add_write_index_relaxed_fn =
|
||||
HSA::hsa_queue_add_write_index_relaxed;
|
||||
core_api.hsa_queue_add_write_index_release_fn =
|
||||
HSA::hsa_queue_add_write_index_release;
|
||||
core_api.hsa_queue_add_write_index_screlease_fn =
|
||||
HSA::hsa_queue_add_write_index_screlease;
|
||||
core_api.hsa_queue_store_read_index_relaxed_fn =
|
||||
HSA::hsa_queue_store_read_index_relaxed;
|
||||
core_api.hsa_queue_store_read_index_release_fn =
|
||||
HSA::hsa_queue_store_read_index_release;
|
||||
core_api.hsa_queue_store_read_index_screlease_fn =
|
||||
HSA::hsa_queue_store_read_index_screlease;
|
||||
core_api.hsa_agent_iterate_regions_fn = HSA::hsa_agent_iterate_regions;
|
||||
core_api.hsa_region_get_info_fn = HSA::hsa_region_get_info;
|
||||
core_api.hsa_memory_register_fn = HSA::hsa_memory_register;
|
||||
@@ -189,52 +189,72 @@ void HsaApiTable::UpdateCore() {
|
||||
core_api.hsa_signal_create_fn = HSA::hsa_signal_create;
|
||||
core_api.hsa_signal_destroy_fn = HSA::hsa_signal_destroy;
|
||||
core_api.hsa_signal_load_relaxed_fn = HSA::hsa_signal_load_relaxed;
|
||||
core_api.hsa_signal_load_acquire_fn = HSA::hsa_signal_load_acquire;
|
||||
core_api.hsa_signal_load_scacquire_fn = HSA::hsa_signal_load_scacquire;
|
||||
core_api.hsa_signal_store_relaxed_fn = HSA::hsa_signal_store_relaxed;
|
||||
core_api.hsa_signal_store_release_fn = HSA::hsa_signal_store_release;
|
||||
core_api.hsa_signal_store_screlease_fn = HSA::hsa_signal_store_screlease;
|
||||
core_api.hsa_signal_wait_relaxed_fn = HSA::hsa_signal_wait_relaxed;
|
||||
core_api.hsa_signal_wait_acquire_fn = HSA::hsa_signal_wait_acquire;
|
||||
core_api.hsa_signal_wait_scacquire_fn = HSA::hsa_signal_wait_scacquire;
|
||||
core_api.hsa_signal_and_relaxed_fn = HSA::hsa_signal_and_relaxed;
|
||||
core_api.hsa_signal_and_acquire_fn = HSA::hsa_signal_and_acquire;
|
||||
core_api.hsa_signal_and_release_fn = HSA::hsa_signal_and_release;
|
||||
core_api.hsa_signal_and_acq_rel_fn = HSA::hsa_signal_and_acq_rel;
|
||||
core_api.hsa_signal_and_scacquire_fn = HSA::hsa_signal_and_scacquire;
|
||||
core_api.hsa_signal_and_screlease_fn = HSA::hsa_signal_and_screlease;
|
||||
core_api.hsa_signal_and_scacq_screl_fn = HSA::hsa_signal_and_scacq_screl;
|
||||
core_api.hsa_signal_or_relaxed_fn = HSA::hsa_signal_or_relaxed;
|
||||
core_api.hsa_signal_or_acquire_fn = HSA::hsa_signal_or_acquire;
|
||||
core_api.hsa_signal_or_release_fn = HSA::hsa_signal_or_release;
|
||||
core_api.hsa_signal_or_acq_rel_fn = HSA::hsa_signal_or_acq_rel;
|
||||
core_api.hsa_signal_or_scacquire_fn = HSA::hsa_signal_or_scacquire;
|
||||
core_api.hsa_signal_or_screlease_fn = HSA::hsa_signal_or_screlease;
|
||||
core_api.hsa_signal_or_scacq_screl_fn = HSA::hsa_signal_or_scacq_screl;
|
||||
core_api.hsa_signal_xor_relaxed_fn = HSA::hsa_signal_xor_relaxed;
|
||||
core_api.hsa_signal_xor_acquire_fn = HSA::hsa_signal_xor_acquire;
|
||||
core_api.hsa_signal_xor_release_fn = HSA::hsa_signal_xor_release;
|
||||
core_api.hsa_signal_xor_acq_rel_fn = HSA::hsa_signal_xor_acq_rel;
|
||||
core_api.hsa_signal_xor_scacquire_fn = HSA::hsa_signal_xor_scacquire;
|
||||
core_api.hsa_signal_xor_screlease_fn = HSA::hsa_signal_xor_screlease;
|
||||
core_api.hsa_signal_xor_scacq_screl_fn = HSA::hsa_signal_xor_scacq_screl;
|
||||
core_api.hsa_signal_exchange_relaxed_fn = HSA::hsa_signal_exchange_relaxed;
|
||||
core_api.hsa_signal_exchange_acquire_fn = HSA::hsa_signal_exchange_acquire;
|
||||
core_api.hsa_signal_exchange_release_fn = HSA::hsa_signal_exchange_release;
|
||||
core_api.hsa_signal_exchange_acq_rel_fn = HSA::hsa_signal_exchange_acq_rel;
|
||||
core_api.hsa_signal_exchange_scacquire_fn = HSA::hsa_signal_exchange_scacquire;
|
||||
core_api.hsa_signal_exchange_screlease_fn = HSA::hsa_signal_exchange_screlease;
|
||||
core_api.hsa_signal_exchange_scacq_screl_fn = HSA::hsa_signal_exchange_scacq_screl;
|
||||
core_api.hsa_signal_add_relaxed_fn = HSA::hsa_signal_add_relaxed;
|
||||
core_api.hsa_signal_add_acquire_fn = HSA::hsa_signal_add_acquire;
|
||||
core_api.hsa_signal_add_release_fn = HSA::hsa_signal_add_release;
|
||||
core_api.hsa_signal_add_acq_rel_fn = HSA::hsa_signal_add_acq_rel;
|
||||
core_api.hsa_signal_add_scacquire_fn = HSA::hsa_signal_add_scacquire;
|
||||
core_api.hsa_signal_add_screlease_fn = HSA::hsa_signal_add_screlease;
|
||||
core_api.hsa_signal_add_scacq_screl_fn = HSA::hsa_signal_add_scacq_screl;
|
||||
core_api.hsa_signal_subtract_relaxed_fn = HSA::hsa_signal_subtract_relaxed;
|
||||
core_api.hsa_signal_subtract_acquire_fn = HSA::hsa_signal_subtract_acquire;
|
||||
core_api.hsa_signal_subtract_release_fn = HSA::hsa_signal_subtract_release;
|
||||
core_api.hsa_signal_subtract_acq_rel_fn = HSA::hsa_signal_subtract_acq_rel;
|
||||
core_api.hsa_signal_subtract_scacquire_fn = HSA::hsa_signal_subtract_scacquire;
|
||||
core_api.hsa_signal_subtract_screlease_fn = HSA::hsa_signal_subtract_screlease;
|
||||
core_api.hsa_signal_subtract_scacq_screl_fn = HSA::hsa_signal_subtract_scacq_screl;
|
||||
core_api.hsa_signal_cas_relaxed_fn = HSA::hsa_signal_cas_relaxed;
|
||||
core_api.hsa_signal_cas_acquire_fn = HSA::hsa_signal_cas_acquire;
|
||||
core_api.hsa_signal_cas_release_fn = HSA::hsa_signal_cas_release;
|
||||
core_api.hsa_signal_cas_acq_rel_fn = HSA::hsa_signal_cas_acq_rel;
|
||||
core_api.hsa_signal_cas_scacquire_fn = HSA::hsa_signal_cas_scacquire;
|
||||
core_api.hsa_signal_cas_screlease_fn = HSA::hsa_signal_cas_screlease;
|
||||
core_api.hsa_signal_cas_scacq_screl_fn = HSA::hsa_signal_cas_scacq_screl;
|
||||
|
||||
//===--- Instruction Set Architecture -----------------------------------===//
|
||||
|
||||
core_api.hsa_isa_from_name_fn = HSA::hsa_isa_from_name;
|
||||
// Deprecated since v1.1.
|
||||
core_api.hsa_isa_get_info_fn = HSA::hsa_isa_get_info;
|
||||
// Deprecated since v1.1.
|
||||
core_api.hsa_isa_compatible_fn = HSA::hsa_isa_compatible;
|
||||
|
||||
//===--- Code Objects (deprecated) --------------------------------------===//
|
||||
|
||||
// Deprecated since v1.1.
|
||||
core_api.hsa_code_object_serialize_fn = HSA::hsa_code_object_serialize;
|
||||
// Deprecated since v1.1.
|
||||
core_api.hsa_code_object_deserialize_fn = HSA::hsa_code_object_deserialize;
|
||||
// Deprecated since v1.1.
|
||||
core_api.hsa_code_object_destroy_fn = HSA::hsa_code_object_destroy;
|
||||
// Deprecated since v1.1.
|
||||
core_api.hsa_code_object_get_info_fn = HSA::hsa_code_object_get_info;
|
||||
// Deprecated since v1.1.
|
||||
core_api.hsa_code_object_get_symbol_fn = HSA::hsa_code_object_get_symbol;
|
||||
// Deprecated since v1.1.
|
||||
core_api.hsa_code_symbol_get_info_fn = HSA::hsa_code_symbol_get_info;
|
||||
// Deprecated since v1.1.
|
||||
core_api.hsa_code_object_iterate_symbols_fn =
|
||||
HSA::hsa_code_object_iterate_symbols;
|
||||
|
||||
//===--- Executable -----------------------------------------------------===//
|
||||
|
||||
// Deprecated since v1.1.
|
||||
core_api.hsa_executable_create_fn = HSA::hsa_executable_create;
|
||||
core_api.hsa_executable_destroy_fn = HSA::hsa_executable_destroy;
|
||||
// Deprecated since v1.1.
|
||||
core_api.hsa_executable_load_code_object_fn =
|
||||
HSA::hsa_executable_load_code_object;
|
||||
core_api.hsa_executable_freeze_fn = HSA::hsa_executable_freeze;
|
||||
@@ -246,10 +266,69 @@ void HsaApiTable::UpdateCore() {
|
||||
core_api.hsa_executable_readonly_variable_define_fn =
|
||||
HSA::hsa_executable_readonly_variable_define;
|
||||
core_api.hsa_executable_validate_fn = HSA::hsa_executable_validate;
|
||||
// Deprecated since v1.1.
|
||||
core_api.hsa_executable_get_symbol_fn = HSA::hsa_executable_get_symbol;
|
||||
core_api.hsa_executable_symbol_get_info_fn = HSA::hsa_executable_symbol_get_info;
|
||||
core_api.hsa_executable_iterate_symbols_fn = HSA::hsa_executable_iterate_symbols;
|
||||
core_api.hsa_executable_symbol_get_info_fn =
|
||||
HSA::hsa_executable_symbol_get_info;
|
||||
// Deprecated since v1.1.
|
||||
core_api.hsa_executable_iterate_symbols_fn =
|
||||
HSA::hsa_executable_iterate_symbols;
|
||||
|
||||
//===--- Runtime Notifications ------------------------------------------===//
|
||||
|
||||
core_api.hsa_status_string_fn = HSA::hsa_status_string;
|
||||
|
||||
//Start HSA v1.1 additions
|
||||
core_api.hsa_extension_get_name_fn = HSA::hsa_extension_get_name;
|
||||
core_api.hsa_system_major_extension_supported_fn = HSA::hsa_system_major_extension_supported;
|
||||
core_api.hsa_system_get_major_extension_table_fn = HSA::hsa_system_get_major_extension_table;
|
||||
core_api.hsa_agent_major_extension_supported_fn = HSA::hsa_agent_major_extension_supported;
|
||||
core_api.hsa_cache_get_info_fn = HSA::hsa_cache_get_info;
|
||||
core_api.hsa_agent_iterate_caches_fn = HSA::hsa_agent_iterate_caches;
|
||||
//Silent store optimization is present in all signal ops when no agents are sleeping.
|
||||
core_api.hsa_signal_silent_store_relaxed_fn = HSA::hsa_signal_store_relaxed;
|
||||
core_api.hsa_signal_silent_store_screlease_fn = HSA::hsa_signal_store_screlease;
|
||||
core_api.hsa_signal_group_create_fn = HSA::hsa_signal_group_create;
|
||||
core_api.hsa_signal_group_destroy_fn = HSA::hsa_signal_group_destroy;
|
||||
core_api.hsa_signal_group_wait_any_scacquire_fn = HSA::hsa_signal_group_wait_any_scacquire;
|
||||
core_api.hsa_signal_group_wait_any_relaxed_fn = HSA::hsa_signal_group_wait_any_relaxed;
|
||||
|
||||
//===--- Instruction Set Architecture - HSA v1.1 additions --------------===//
|
||||
|
||||
core_api.hsa_agent_iterate_isas_fn = HSA::hsa_agent_iterate_isas;
|
||||
core_api.hsa_isa_get_info_alt_fn = HSA::hsa_isa_get_info_alt;
|
||||
core_api.hsa_isa_get_exception_policies_fn =
|
||||
HSA::hsa_isa_get_exception_policies;
|
||||
core_api.hsa_isa_get_round_method_fn = HSA::hsa_isa_get_round_method;
|
||||
core_api.hsa_wavefront_get_info_fn = HSA::hsa_wavefront_get_info;
|
||||
core_api.hsa_isa_iterate_wavefronts_fn = HSA::hsa_isa_iterate_wavefronts;
|
||||
|
||||
//===--- Code Objects (deprecated) - HSA v1.1 additions -----------------===//
|
||||
|
||||
// Deprecated since v1.1.
|
||||
core_api.hsa_code_object_get_symbol_from_name_fn =
|
||||
HSA::hsa_code_object_get_symbol_from_name;
|
||||
|
||||
//===--- Executable - HSA v1.1 additions --------------------------------===//
|
||||
|
||||
core_api.hsa_code_object_reader_create_from_file_fn =
|
||||
HSA::hsa_code_object_reader_create_from_file;
|
||||
core_api.hsa_code_object_reader_create_from_memory_fn =
|
||||
HSA::hsa_code_object_reader_create_from_memory;
|
||||
core_api.hsa_code_object_reader_destroy_fn =
|
||||
HSA::hsa_code_object_reader_destroy;
|
||||
core_api.hsa_executable_create_alt_fn = HSA::hsa_executable_create_alt;
|
||||
core_api.hsa_executable_load_program_code_object_fn =
|
||||
HSA::hsa_executable_load_program_code_object;
|
||||
core_api.hsa_executable_load_agent_code_object_fn =
|
||||
HSA::hsa_executable_load_agent_code_object;
|
||||
core_api.hsa_executable_validate_alt_fn = HSA::hsa_executable_validate_alt;
|
||||
core_api.hsa_executable_get_symbol_by_name_fn =
|
||||
HSA::hsa_executable_get_symbol_by_name;
|
||||
core_api.hsa_executable_iterate_agent_symbols_fn =
|
||||
HSA::hsa_executable_iterate_agent_symbols;
|
||||
core_api.hsa_executable_iterate_program_symbols_fn =
|
||||
HSA::hsa_executable_iterate_program_symbols;
|
||||
}
|
||||
|
||||
// Update Api table for Amd Extensions.
|
||||
|
||||
@@ -47,6 +47,24 @@
|
||||
|
||||
namespace core {
|
||||
|
||||
bool Wavefront::GetInfo(
|
||||
const hsa_wavefront_info_t &attribute,
|
||||
void *value) const {
|
||||
if (!value) {
|
||||
return false;
|
||||
}
|
||||
|
||||
switch (attribute) {
|
||||
case HSA_WAVEFRONT_INFO_SIZE: {
|
||||
*((uint32_t*)value) = 64;
|
||||
return true;
|
||||
}
|
||||
default: {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
std::string Isa::GetFullName() const {
|
||||
std::stringstream full_name;
|
||||
full_name << GetVendor() << ":" << GetArchitecture() << ":"
|
||||
@@ -63,27 +81,82 @@ bool Isa::GetInfo(const hsa_isa_info_t &attribute, void *value) const {
|
||||
switch (attribute) {
|
||||
case HSA_ISA_INFO_NAME_LENGTH: {
|
||||
std::string full_name = GetFullName();
|
||||
*((uint32_t *)value) = static_cast<uint32_t>(full_name.size());
|
||||
*((uint32_t*)value) = static_cast<uint32_t>(full_name.size() + 1);
|
||||
return true;
|
||||
}
|
||||
case HSA_ISA_INFO_NAME: {
|
||||
std::string full_name = GetFullName();
|
||||
memset(value, 0x0, full_name.size() + 1);
|
||||
memcpy(value, full_name.c_str(), full_name.size());
|
||||
return true;
|
||||
}
|
||||
// @todo: following case needs to be removed.
|
||||
// deprecated.
|
||||
case HSA_ISA_INFO_CALL_CONVENTION_COUNT: {
|
||||
*((uint32_t *)value) = 1;
|
||||
*((uint32_t*)value) = 1;
|
||||
return true;
|
||||
}
|
||||
// @todo: following case needs to be removed.
|
||||
// deprecated.
|
||||
case HSA_ISA_INFO_CALL_CONVENTION_INFO_WAVEFRONT_SIZE: {
|
||||
*((uint32_t *)value) = 64;
|
||||
*((uint32_t*)value) = 64;
|
||||
return true;
|
||||
}
|
||||
// @todo: following needs to be removed.
|
||||
// deprecated.
|
||||
case HSA_ISA_INFO_CALL_CONVENTION_INFO_WAVEFRONTS_PER_COMPUTE_UNIT: {
|
||||
*((uint32_t *)value) = 40;
|
||||
*((uint32_t*)value) = 40;
|
||||
return true;
|
||||
}
|
||||
case HSA_ISA_INFO_MACHINE_MODELS: {
|
||||
const bool machine_models[2] = {false, true};
|
||||
memcpy(value, machine_models, sizeof(machine_models));
|
||||
return true;
|
||||
}
|
||||
case HSA_ISA_INFO_PROFILES: {
|
||||
bool profiles[2] = {true, false};
|
||||
if (this->version() == Version(7, 0, 0) ||
|
||||
this->version() == Version(8, 0, 1)) {
|
||||
profiles[1] = true;
|
||||
}
|
||||
memcpy(value, profiles, sizeof(profiles));
|
||||
return true;
|
||||
}
|
||||
case HSA_ISA_INFO_DEFAULT_FLOAT_ROUNDING_MODES: {
|
||||
const bool rounding_modes[3] = {false, false, true};
|
||||
memcpy(value, rounding_modes, sizeof(rounding_modes));
|
||||
return true;
|
||||
}
|
||||
case HSA_ISA_INFO_BASE_PROFILE_DEFAULT_FLOAT_ROUNDING_MODES: {
|
||||
const bool rounding_modes[3] = {false, false, true};
|
||||
memcpy(value, rounding_modes, sizeof(rounding_modes));
|
||||
return true;
|
||||
}
|
||||
case HSA_ISA_INFO_FAST_F16_OPERATION: {
|
||||
if (this->GetMajorVersion() >= 8) {
|
||||
*((bool*)value) = true;
|
||||
} else {
|
||||
*((bool*)value) = false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
case HSA_ISA_INFO_WORKGROUP_MAX_DIM: {
|
||||
const uint16_t workgroup_max_dim[3] = {1024, 1024, 1024};
|
||||
memcpy(value, workgroup_max_dim, sizeof(workgroup_max_dim));
|
||||
return true;
|
||||
}
|
||||
case HSA_ISA_INFO_WORKGROUP_MAX_SIZE: {
|
||||
*((uint32_t*)value) = 1024;
|
||||
return true;
|
||||
}
|
||||
case HSA_ISA_INFO_GRID_MAX_DIM: {
|
||||
const hsa_dim3_t grid_max_dim = {UINT32_MAX, UINT32_MAX, UINT32_MAX};
|
||||
memcpy(value, &grid_max_dim, sizeof(grid_max_dim));
|
||||
return true;
|
||||
}
|
||||
case HSA_ISA_INFO_GRID_MAX_SIZE: {
|
||||
*((uint64_t*)value) = UINT64_MAX;
|
||||
return true;
|
||||
}
|
||||
case HSA_ISA_INFO_FBARRIER_MAX_SIZE: {
|
||||
*((uint32_t*)value) = 32;
|
||||
return true;
|
||||
}
|
||||
default: {
|
||||
@@ -92,6 +165,12 @@ bool Isa::GetInfo(const hsa_isa_info_t &attribute, void *value) const {
|
||||
}
|
||||
}
|
||||
|
||||
hsa_round_method_t Isa::GetRoundMethod(
|
||||
hsa_fp_type_t fp_type,
|
||||
hsa_flush_mode_t flush_mode) const {
|
||||
return HSA_ROUND_METHOD_SINGLE;
|
||||
}
|
||||
|
||||
const Isa *IsaRegistry::GetIsa(const std::string &full_name) {
|
||||
auto isareg_iter = supported_isas_.find(full_name);
|
||||
return isareg_iter == supported_isas_.end() ? nullptr : &isareg_iter->second;
|
||||
@@ -117,11 +196,9 @@ const IsaRegistry::IsaMap IsaRegistry::GetSupportedIsas() {
|
||||
|
||||
ISAREG_ENTRY_GEN(7, 0, 0)
|
||||
ISAREG_ENTRY_GEN(7, 0, 1)
|
||||
ISAREG_ENTRY_GEN(8, 0, 0)
|
||||
ISAREG_ENTRY_GEN(8, 0, 1)
|
||||
ISAREG_ENTRY_GEN(8, 0, 2)
|
||||
ISAREG_ENTRY_GEN(8, 0, 3)
|
||||
ISAREG_ENTRY_GEN(8, 1, 0)
|
||||
ISAREG_ENTRY_GEN(9, 0, 0)
|
||||
|
||||
return supported_isas;
|
||||
|
||||
@@ -63,7 +63,7 @@
|
||||
#include "core/inc/hsa_api_trace_int.h"
|
||||
|
||||
#define HSA_VERSION_MAJOR 1
|
||||
#define HSA_VERSION_MINOR 0
|
||||
#define HSA_VERSION_MINOR 1
|
||||
|
||||
const char rocrbuildid[] = "ROCR BUILD ID: " STRING(ROCR_BUILD_ID);
|
||||
|
||||
@@ -526,19 +526,23 @@ hsa_status_t Runtime::GetSystemInfo(hsa_system_info_t attribute, void* value) {
|
||||
#endif
|
||||
break;
|
||||
case HSA_SYSTEM_INFO_EXTENSIONS:
|
||||
memset(value, 0, sizeof(uint8_t) * 128);
|
||||
{
|
||||
memset(value, 0, sizeof(uint8_t) * 128);
|
||||
|
||||
if (hsa_internal_api_table_.finalizer_api.hsa_ext_program_finalize_fn != NULL) {
|
||||
*((uint8_t*)value) = 1 << HSA_EXTENSION_FINALIZER;
|
||||
auto setFlag = [&](uint32_t bit) { assert(bit<128*8 && "Extension value exceeds extension bitmask"); uint index = bit/8; uint subBit = bit%8; ((uint8_t*)value)[index] |= 1<<subBit; };
|
||||
|
||||
if (hsa_internal_api_table_.finalizer_api.hsa_ext_program_finalize_fn != NULL) {
|
||||
setFlag(HSA_EXTENSION_FINALIZER);
|
||||
}
|
||||
|
||||
if (hsa_internal_api_table_.image_api.hsa_ext_image_create_fn != NULL) {
|
||||
setFlag(HSA_EXTENSION_IMAGES);
|
||||
}
|
||||
|
||||
setFlag(HSA_EXTENSION_AMD_PROFILER);
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
if (hsa_internal_api_table_.image_api.hsa_ext_image_create_fn != NULL) {
|
||||
*((uint8_t*)value) |= 1 << HSA_EXTENSION_IMAGES;
|
||||
}
|
||||
|
||||
*((uint8_t*)value) |= 1 << HSA_EXTENSION_AMD_PROFILER;
|
||||
|
||||
break;
|
||||
default:
|
||||
return HSA_STATUS_ERROR_INVALID_ARGUMENT;
|
||||
}
|
||||
|
||||
@@ -49,13 +49,13 @@
|
||||
|
||||
namespace core {
|
||||
|
||||
uint32_t Signal::WaitAny(uint32_t signal_count, hsa_signal_t* hsa_signals,
|
||||
hsa_signal_condition_t* conds,
|
||||
hsa_signal_value_t* values, uint64_t timeout,
|
||||
uint32_t Signal::WaitAny(uint32_t signal_count, const hsa_signal_t* hsa_signals,
|
||||
const hsa_signal_condition_t* conds,
|
||||
const hsa_signal_value_t* values, uint64_t timeout,
|
||||
hsa_wait_state_t wait_hint,
|
||||
hsa_signal_value_t* satisfying_value) {
|
||||
hsa_signal_handle* signals =
|
||||
reinterpret_cast<hsa_signal_handle*>(hsa_signals);
|
||||
reinterpret_cast<hsa_signal_handle*>(const_cast<hsa_signal_t*>(hsa_signals));
|
||||
uint32_t prior = 0;
|
||||
for (uint32_t i = 0; i < signal_count; i++)
|
||||
prior = Max(prior, atomic::Increment(&signals[i]->waiting_));
|
||||
@@ -182,6 +182,18 @@ uint32_t Signal::WaitAny(uint32_t signal_count, hsa_signal_t* hsa_signals,
|
||||
}
|
||||
}
|
||||
|
||||
SignalGroup::SignalGroup(uint32_t num_signals, const hsa_signal_t* hsa_signals) : count(num_signals)
|
||||
{
|
||||
if(count!=0)
|
||||
signals=new hsa_signal_t[count];
|
||||
else
|
||||
signals=NULL;
|
||||
if(signals==NULL)
|
||||
return;
|
||||
for(int i=0; i<count; i++)
|
||||
signals[i]=hsa_signals[i];
|
||||
}
|
||||
|
||||
} // namespace core
|
||||
|
||||
#endif // header guard
|
||||
|
||||
Fichier diff supprimé car celui-ci est trop grand
Voir la Diff
@@ -145,102 +145,281 @@ struct AmdExtTable {
|
||||
// Table to export HSA Core Runtime Apis
|
||||
struct CoreApiTable {
|
||||
ApiTableVersion version;
|
||||
decltype(hsa_init)* hsa_init_fn;
|
||||
decltype(hsa_shut_down)* hsa_shut_down_fn;
|
||||
decltype(hsa_system_get_info)* hsa_system_get_info_fn;
|
||||
decltype(hsa_system_extension_supported)* hsa_system_extension_supported_fn;
|
||||
decltype(hsa_system_get_extension_table)* hsa_system_get_extension_table_fn;
|
||||
decltype(hsa_iterate_agents)* hsa_iterate_agents_fn;
|
||||
decltype(hsa_agent_get_info)* hsa_agent_get_info_fn;
|
||||
decltype(hsa_queue_create)* hsa_queue_create_fn;
|
||||
decltype(hsa_soft_queue_create)* hsa_soft_queue_create_fn;
|
||||
decltype(hsa_queue_destroy)* hsa_queue_destroy_fn;
|
||||
decltype(hsa_queue_inactivate)* hsa_queue_inactivate_fn;
|
||||
decltype(hsa_queue_load_read_index_acquire)* hsa_queue_load_read_index_acquire_fn;
|
||||
decltype(hsa_queue_load_read_index_relaxed)* hsa_queue_load_read_index_relaxed_fn;
|
||||
decltype(hsa_queue_load_write_index_acquire)* hsa_queue_load_write_index_acquire_fn;
|
||||
decltype(hsa_queue_load_write_index_relaxed)* hsa_queue_load_write_index_relaxed_fn;
|
||||
decltype(hsa_queue_store_write_index_relaxed)* hsa_queue_store_write_index_relaxed_fn;
|
||||
decltype(hsa_queue_store_write_index_release)* hsa_queue_store_write_index_release_fn;
|
||||
decltype(hsa_queue_cas_write_index_acq_rel)* hsa_queue_cas_write_index_acq_rel_fn;
|
||||
decltype(hsa_queue_cas_write_index_acquire)* hsa_queue_cas_write_index_acquire_fn;
|
||||
decltype(hsa_queue_cas_write_index_relaxed)* hsa_queue_cas_write_index_relaxed_fn;
|
||||
decltype(hsa_queue_cas_write_index_release)* hsa_queue_cas_write_index_release_fn;
|
||||
decltype(hsa_queue_add_write_index_acq_rel)* hsa_queue_add_write_index_acq_rel_fn;
|
||||
decltype(hsa_queue_add_write_index_acquire)* hsa_queue_add_write_index_acquire_fn;
|
||||
decltype(hsa_queue_add_write_index_relaxed)* hsa_queue_add_write_index_relaxed_fn;
|
||||
decltype(hsa_queue_add_write_index_release)* hsa_queue_add_write_index_release_fn;
|
||||
decltype(hsa_queue_store_read_index_relaxed)* hsa_queue_store_read_index_relaxed_fn;
|
||||
decltype(hsa_queue_store_read_index_release)* hsa_queue_store_read_index_release_fn;
|
||||
decltype(hsa_agent_iterate_regions)* hsa_agent_iterate_regions_fn;
|
||||
decltype(hsa_region_get_info)* hsa_region_get_info_fn;
|
||||
decltype(hsa_agent_get_exception_policies)* hsa_agent_get_exception_policies_fn;
|
||||
decltype(hsa_agent_extension_supported)* hsa_agent_extension_supported_fn;
|
||||
decltype(hsa_memory_register)* hsa_memory_register_fn;
|
||||
decltype(hsa_memory_deregister)* hsa_memory_deregister_fn;
|
||||
decltype(hsa_memory_allocate)* hsa_memory_allocate_fn;
|
||||
decltype(hsa_memory_free)* hsa_memory_free_fn;
|
||||
decltype(hsa_memory_copy)* hsa_memory_copy_fn;
|
||||
decltype(hsa_memory_assign_agent)* hsa_memory_assign_agent_fn;
|
||||
decltype(hsa_signal_create)* hsa_signal_create_fn;
|
||||
decltype(hsa_signal_destroy)* hsa_signal_destroy_fn;
|
||||
decltype(hsa_signal_load_relaxed)* hsa_signal_load_relaxed_fn;
|
||||
decltype(hsa_signal_load_acquire)* hsa_signal_load_acquire_fn;
|
||||
decltype(hsa_signal_store_relaxed)* hsa_signal_store_relaxed_fn;
|
||||
decltype(hsa_signal_store_release)* hsa_signal_store_release_fn;
|
||||
decltype(hsa_signal_wait_relaxed)* hsa_signal_wait_relaxed_fn;
|
||||
decltype(hsa_signal_wait_acquire)* hsa_signal_wait_acquire_fn;
|
||||
decltype(hsa_signal_and_relaxed)* hsa_signal_and_relaxed_fn;
|
||||
decltype(hsa_signal_and_acquire)* hsa_signal_and_acquire_fn;
|
||||
decltype(hsa_signal_and_release)* hsa_signal_and_release_fn;
|
||||
decltype(hsa_signal_and_acq_rel)* hsa_signal_and_acq_rel_fn;
|
||||
decltype(hsa_signal_or_relaxed)* hsa_signal_or_relaxed_fn;
|
||||
decltype(hsa_signal_or_acquire)* hsa_signal_or_acquire_fn;
|
||||
decltype(hsa_signal_or_release)* hsa_signal_or_release_fn;
|
||||
decltype(hsa_signal_or_acq_rel)* hsa_signal_or_acq_rel_fn;
|
||||
decltype(hsa_signal_xor_relaxed)* hsa_signal_xor_relaxed_fn;
|
||||
decltype(hsa_signal_xor_acquire)* hsa_signal_xor_acquire_fn;
|
||||
decltype(hsa_signal_xor_release)* hsa_signal_xor_release_fn;
|
||||
decltype(hsa_signal_xor_acq_rel)* hsa_signal_xor_acq_rel_fn;
|
||||
decltype(hsa_signal_exchange_relaxed)* hsa_signal_exchange_relaxed_fn;
|
||||
decltype(hsa_signal_exchange_acquire)* hsa_signal_exchange_acquire_fn;
|
||||
decltype(hsa_signal_exchange_release)* hsa_signal_exchange_release_fn;
|
||||
decltype(hsa_signal_exchange_acq_rel)* hsa_signal_exchange_acq_rel_fn;
|
||||
decltype(hsa_signal_add_relaxed)* hsa_signal_add_relaxed_fn;
|
||||
decltype(hsa_signal_add_acquire)* hsa_signal_add_acquire_fn;
|
||||
decltype(hsa_signal_add_release)* hsa_signal_add_release_fn;
|
||||
decltype(hsa_signal_add_acq_rel)* hsa_signal_add_acq_rel_fn;
|
||||
decltype(hsa_signal_subtract_relaxed)* hsa_signal_subtract_relaxed_fn;
|
||||
decltype(hsa_signal_subtract_acquire)* hsa_signal_subtract_acquire_fn;
|
||||
decltype(hsa_signal_subtract_release)* hsa_signal_subtract_release_fn;
|
||||
decltype(hsa_signal_subtract_acq_rel)* hsa_signal_subtract_acq_rel_fn;
|
||||
decltype(hsa_signal_cas_relaxed)* hsa_signal_cas_relaxed_fn;
|
||||
decltype(hsa_signal_cas_acquire)* hsa_signal_cas_acquire_fn;
|
||||
decltype(hsa_signal_cas_release)* hsa_signal_cas_release_fn;
|
||||
decltype(hsa_signal_cas_acq_rel)* hsa_signal_cas_acq_rel_fn;
|
||||
decltype(hsa_isa_from_name)* hsa_isa_from_name_fn;
|
||||
decltype(hsa_isa_get_info)* hsa_isa_get_info_fn;
|
||||
decltype(hsa_isa_compatible)* hsa_isa_compatible_fn;
|
||||
decltype(hsa_code_object_serialize)* hsa_code_object_serialize_fn;
|
||||
decltype(hsa_code_object_deserialize)* hsa_code_object_deserialize_fn;
|
||||
decltype(hsa_code_object_destroy)* hsa_code_object_destroy_fn;
|
||||
decltype(hsa_code_object_get_info)* hsa_code_object_get_info_fn;
|
||||
decltype(hsa_code_object_get_symbol)* hsa_code_object_get_symbol_fn;
|
||||
decltype(hsa_code_symbol_get_info)* hsa_code_symbol_get_info_fn;
|
||||
decltype(hsa_code_object_iterate_symbols)* hsa_code_object_iterate_symbols_fn;
|
||||
decltype(hsa_executable_create)* hsa_executable_create_fn;
|
||||
decltype(hsa_executable_destroy)* hsa_executable_destroy_fn;
|
||||
decltype(hsa_executable_load_code_object)* hsa_executable_load_code_object_fn;
|
||||
decltype(hsa_executable_freeze)* hsa_executable_freeze_fn;
|
||||
decltype(hsa_executable_get_info)* hsa_executable_get_info_fn;
|
||||
decltype(hsa_executable_global_variable_define)* hsa_executable_global_variable_define_fn;
|
||||
decltype(hsa_executable_agent_global_variable_define)* hsa_executable_agent_global_variable_define_fn;
|
||||
decltype(hsa_executable_readonly_variable_define)* hsa_executable_readonly_variable_define_fn;
|
||||
decltype(hsa_executable_validate)* hsa_executable_validate_fn;
|
||||
decltype(hsa_executable_get_symbol)* hsa_executable_get_symbol_fn;
|
||||
decltype(hsa_executable_symbol_get_info)* hsa_executable_symbol_get_info_fn;
|
||||
decltype(hsa_executable_iterate_symbols)* hsa_executable_iterate_symbols_fn;
|
||||
decltype(hsa_status_string)* hsa_status_string_fn;
|
||||
decltype(hsa_init)* hsa_init_fn;
|
||||
decltype(hsa_shut_down)* hsa_shut_down_fn;
|
||||
decltype(hsa_system_get_info)* hsa_system_get_info_fn;
|
||||
decltype(hsa_system_extension_supported)* hsa_system_extension_supported_fn;
|
||||
decltype(hsa_system_get_extension_table)* hsa_system_get_extension_table_fn;
|
||||
decltype(hsa_iterate_agents)* hsa_iterate_agents_fn;
|
||||
decltype(hsa_agent_get_info)* hsa_agent_get_info_fn;
|
||||
decltype(hsa_queue_create)* hsa_queue_create_fn;
|
||||
decltype(hsa_soft_queue_create)* hsa_soft_queue_create_fn;
|
||||
decltype(hsa_queue_destroy)* hsa_queue_destroy_fn;
|
||||
decltype(hsa_queue_inactivate)* hsa_queue_inactivate_fn;
|
||||
union {
|
||||
decltype(hsa_queue_load_read_index_scacquire)* hsa_queue_load_read_index_scacquire_fn;
|
||||
decltype(hsa_queue_load_read_index_acquire)* hsa_queue_load_read_index_acquire_fn;
|
||||
};
|
||||
decltype(hsa_queue_load_read_index_relaxed)* hsa_queue_load_read_index_relaxed_fn;
|
||||
union {
|
||||
decltype(hsa_queue_load_write_index_scacquire)* hsa_queue_load_write_index_scacquire_fn;
|
||||
decltype(hsa_queue_load_write_index_acquire)* hsa_queue_load_write_index_acquire_fn;
|
||||
};
|
||||
decltype(hsa_queue_load_write_index_relaxed)* hsa_queue_load_write_index_relaxed_fn;
|
||||
decltype(hsa_queue_store_write_index_relaxed)* hsa_queue_store_write_index_relaxed_fn;
|
||||
union {
|
||||
decltype(hsa_queue_store_write_index_screlease)* hsa_queue_store_write_index_screlease_fn;
|
||||
decltype(hsa_queue_store_write_index_release)* hsa_queue_store_write_index_release_fn;
|
||||
};
|
||||
union {
|
||||
decltype(hsa_queue_cas_write_index_scacq_screl)* hsa_queue_cas_write_index_scacq_screl_fn;
|
||||
decltype(hsa_queue_cas_write_index_acq_rel)* hsa_queue_cas_write_index_acq_rel_fn;
|
||||
};
|
||||
union {
|
||||
decltype(hsa_queue_cas_write_index_scacquire)* hsa_queue_cas_write_index_scacquire_fn;
|
||||
decltype(hsa_queue_cas_write_index_acquire)* hsa_queue_cas_write_index_acquire_fn;
|
||||
};
|
||||
decltype(hsa_queue_cas_write_index_relaxed)* hsa_queue_cas_write_index_relaxed_fn;
|
||||
union {
|
||||
decltype(hsa_queue_cas_write_index_screlease)* hsa_queue_cas_write_index_screlease_fn;
|
||||
decltype(hsa_queue_cas_write_index_release)* hsa_queue_cas_write_index_release_fn;
|
||||
};
|
||||
union {
|
||||
decltype(hsa_queue_add_write_index_scacq_screl)* hsa_queue_add_write_index_scacq_screl_fn;
|
||||
decltype(hsa_queue_add_write_index_acq_rel)* hsa_queue_add_write_index_acq_rel_fn;
|
||||
};
|
||||
union {
|
||||
decltype(hsa_queue_add_write_index_scacquire)* hsa_queue_add_write_index_scacquire_fn;
|
||||
decltype(hsa_queue_add_write_index_acquire)* hsa_queue_add_write_index_acquire_fn;
|
||||
};
|
||||
decltype(hsa_queue_add_write_index_relaxed)* hsa_queue_add_write_index_relaxed_fn;
|
||||
union {
|
||||
decltype(hsa_queue_add_write_index_screlease)* hsa_queue_add_write_index_screlease_fn;
|
||||
decltype(hsa_queue_add_write_index_release)* hsa_queue_add_write_index_release_fn;
|
||||
};
|
||||
decltype(hsa_queue_store_read_index_relaxed)* hsa_queue_store_read_index_relaxed_fn;
|
||||
union {
|
||||
decltype(hsa_queue_store_read_index_screlease)* hsa_queue_store_read_index_screlease_fn;
|
||||
decltype(hsa_queue_store_read_index_release)* hsa_queue_store_read_index_release_fn;
|
||||
};
|
||||
decltype(hsa_agent_iterate_regions)* hsa_agent_iterate_regions_fn;
|
||||
decltype(hsa_region_get_info)* hsa_region_get_info_fn;
|
||||
decltype(hsa_agent_get_exception_policies)* hsa_agent_get_exception_policies_fn;
|
||||
decltype(hsa_agent_extension_supported)* hsa_agent_extension_supported_fn;
|
||||
decltype(hsa_memory_register)* hsa_memory_register_fn;
|
||||
decltype(hsa_memory_deregister)* hsa_memory_deregister_fn;
|
||||
decltype(hsa_memory_allocate)* hsa_memory_allocate_fn;
|
||||
decltype(hsa_memory_free)* hsa_memory_free_fn;
|
||||
decltype(hsa_memory_copy)* hsa_memory_copy_fn;
|
||||
decltype(hsa_memory_assign_agent)* hsa_memory_assign_agent_fn;
|
||||
decltype(hsa_signal_create)* hsa_signal_create_fn;
|
||||
decltype(hsa_signal_destroy)* hsa_signal_destroy_fn;
|
||||
decltype(hsa_signal_load_relaxed)* hsa_signal_load_relaxed_fn;
|
||||
union {
|
||||
decltype(hsa_signal_load_scacquire)* hsa_signal_load_scacquire_fn;
|
||||
decltype(hsa_signal_load_acquire)* hsa_signal_load_acquire_fn;
|
||||
};
|
||||
decltype(hsa_signal_store_relaxed)* hsa_signal_store_relaxed_fn;
|
||||
union {
|
||||
decltype(hsa_signal_store_screlease)* hsa_signal_store_screlease_fn;
|
||||
decltype(hsa_signal_store_release)* hsa_signal_store_release_fn;
|
||||
};
|
||||
decltype(hsa_signal_wait_relaxed)* hsa_signal_wait_relaxed_fn;
|
||||
union {
|
||||
decltype(hsa_signal_wait_scacquire)* hsa_signal_wait_scacquire_fn;
|
||||
decltype(hsa_signal_wait_acquire)* hsa_signal_wait_acquire_fn;
|
||||
};
|
||||
decltype(hsa_signal_and_relaxed)* hsa_signal_and_relaxed_fn;
|
||||
union {
|
||||
decltype(hsa_signal_and_scacquire)* hsa_signal_and_scacquire_fn;
|
||||
decltype(hsa_signal_and_acquire)* hsa_signal_and_acquire_fn;
|
||||
};
|
||||
union {
|
||||
decltype(hsa_signal_and_screlease)* hsa_signal_and_screlease_fn;
|
||||
decltype(hsa_signal_and_release)* hsa_signal_and_release_fn;
|
||||
};
|
||||
union {
|
||||
decltype(hsa_signal_and_scacq_screl)* hsa_signal_and_scacq_screl_fn;
|
||||
decltype(hsa_signal_and_acq_rel)* hsa_signal_and_acq_rel_fn;
|
||||
};
|
||||
decltype(hsa_signal_or_relaxed)* hsa_signal_or_relaxed_fn;
|
||||
union {
|
||||
decltype(hsa_signal_or_scacquire)* hsa_signal_or_scacquire_fn;
|
||||
decltype(hsa_signal_or_acquire)* hsa_signal_or_acquire_fn;
|
||||
};
|
||||
union {
|
||||
decltype(hsa_signal_or_screlease)* hsa_signal_or_screlease_fn;
|
||||
decltype(hsa_signal_or_release)* hsa_signal_or_release_fn;
|
||||
};
|
||||
union {
|
||||
decltype(hsa_signal_or_scacq_screl)* hsa_signal_or_scacq_screl_fn;
|
||||
decltype(hsa_signal_or_acq_rel)* hsa_signal_or_acq_rel_fn;
|
||||
};
|
||||
decltype(hsa_signal_xor_relaxed)* hsa_signal_xor_relaxed_fn;
|
||||
union {
|
||||
decltype(hsa_signal_xor_scacquire)* hsa_signal_xor_scacquire_fn;
|
||||
decltype(hsa_signal_xor_acquire)* hsa_signal_xor_acquire_fn;
|
||||
};
|
||||
union {
|
||||
decltype(hsa_signal_xor_screlease)* hsa_signal_xor_screlease_fn;
|
||||
decltype(hsa_signal_xor_release)* hsa_signal_xor_release_fn;
|
||||
};
|
||||
union {
|
||||
decltype(hsa_signal_xor_scacq_screl)* hsa_signal_xor_scacq_screl_fn;
|
||||
decltype(hsa_signal_xor_acq_rel)* hsa_signal_xor_acq_rel_fn;
|
||||
};
|
||||
decltype(hsa_signal_exchange_relaxed)* hsa_signal_exchange_relaxed_fn;
|
||||
union {
|
||||
decltype(hsa_signal_exchange_scacquire)* hsa_signal_exchange_scacquire_fn;
|
||||
decltype(hsa_signal_exchange_acquire)* hsa_signal_exchange_acquire_fn;
|
||||
};
|
||||
union {
|
||||
decltype(hsa_signal_exchange_screlease)* hsa_signal_exchange_screlease_fn;
|
||||
decltype(hsa_signal_exchange_release)* hsa_signal_exchange_release_fn;
|
||||
};
|
||||
union {
|
||||
decltype(hsa_signal_exchange_scacq_screl)* hsa_signal_exchange_scacq_screl_fn;
|
||||
decltype(hsa_signal_exchange_acq_rel)* hsa_signal_exchange_acq_rel_fn;
|
||||
};
|
||||
decltype(hsa_signal_add_relaxed)* hsa_signal_add_relaxed_fn;
|
||||
union {
|
||||
decltype(hsa_signal_add_scacquire)* hsa_signal_add_scacquire_fn;
|
||||
decltype(hsa_signal_add_acquire)* hsa_signal_add_acquire_fn;
|
||||
};
|
||||
union {
|
||||
decltype(hsa_signal_add_screlease)* hsa_signal_add_screlease_fn;
|
||||
decltype(hsa_signal_add_release)* hsa_signal_add_release_fn;
|
||||
};
|
||||
union {
|
||||
decltype(hsa_signal_add_scacq_screl)* hsa_signal_add_scacq_screl_fn;
|
||||
decltype(hsa_signal_add_acq_rel)* hsa_signal_add_acq_rel_fn;
|
||||
};
|
||||
decltype(hsa_signal_subtract_relaxed)* hsa_signal_subtract_relaxed_fn;
|
||||
union {
|
||||
decltype(hsa_signal_subtract_scacquire)* hsa_signal_subtract_scacquire_fn;
|
||||
decltype(hsa_signal_subtract_acquire)* hsa_signal_subtract_acquire_fn;
|
||||
};
|
||||
union {
|
||||
decltype(hsa_signal_subtract_screlease)* hsa_signal_subtract_screlease_fn;
|
||||
decltype(hsa_signal_subtract_release)* hsa_signal_subtract_release_fn;
|
||||
};
|
||||
union {
|
||||
decltype(hsa_signal_subtract_scacq_screl)* hsa_signal_subtract_scacq_screl_fn;
|
||||
decltype(hsa_signal_subtract_acq_rel)* hsa_signal_subtract_acq_rel_fn;
|
||||
};
|
||||
decltype(hsa_signal_cas_relaxed)* hsa_signal_cas_relaxed_fn;
|
||||
union {
|
||||
decltype(hsa_signal_cas_scacquire)* hsa_signal_cas_scacquire_fn;
|
||||
decltype(hsa_signal_cas_acquire)* hsa_signal_cas_acquire_fn;
|
||||
};
|
||||
union {
|
||||
decltype(hsa_signal_cas_screlease)* hsa_signal_cas_screlease_fn;
|
||||
decltype(hsa_signal_cas_release)* hsa_signal_cas_release_fn;
|
||||
};
|
||||
union {
|
||||
decltype(hsa_signal_cas_scacq_screl)* hsa_signal_cas_scacq_screl_fn;
|
||||
decltype(hsa_signal_cas_acq_rel)* hsa_signal_cas_acq_rel_fn;
|
||||
};
|
||||
|
||||
//===--- Instruction Set Architecture -----------------------------------===//
|
||||
|
||||
decltype(hsa_isa_from_name)* hsa_isa_from_name_fn;
|
||||
// Deprecated since v1.1.
|
||||
decltype(hsa_isa_get_info)* hsa_isa_get_info_fn;
|
||||
// Deprecated since v1.1.
|
||||
decltype(hsa_isa_compatible)* hsa_isa_compatible_fn;
|
||||
|
||||
//===--- Code Objects (deprecated) --------------------------------------===//
|
||||
|
||||
// Deprecated since v1.1.
|
||||
decltype(hsa_code_object_serialize)* hsa_code_object_serialize_fn;
|
||||
// Deprecated since v1.1.
|
||||
decltype(hsa_code_object_deserialize)* hsa_code_object_deserialize_fn;
|
||||
// Deprecated since v1.1.
|
||||
decltype(hsa_code_object_destroy)* hsa_code_object_destroy_fn;
|
||||
// Deprecated since v1.1.
|
||||
decltype(hsa_code_object_get_info)* hsa_code_object_get_info_fn;
|
||||
// Deprecated since v1.1.
|
||||
decltype(hsa_code_object_get_symbol)* hsa_code_object_get_symbol_fn;
|
||||
// Deprecated since v1.1.
|
||||
decltype(hsa_code_symbol_get_info)* hsa_code_symbol_get_info_fn;
|
||||
// Deprecated since v1.1.
|
||||
decltype(hsa_code_object_iterate_symbols)* hsa_code_object_iterate_symbols_fn;
|
||||
|
||||
//===--- Executable -----------------------------------------------------===//
|
||||
|
||||
// Deprecated since v1.1.
|
||||
decltype(hsa_executable_create)* hsa_executable_create_fn;
|
||||
decltype(hsa_executable_destroy)* hsa_executable_destroy_fn;
|
||||
// Deprecated since v1.1.
|
||||
decltype(hsa_executable_load_code_object)* hsa_executable_load_code_object_fn;
|
||||
decltype(hsa_executable_freeze)* hsa_executable_freeze_fn;
|
||||
decltype(hsa_executable_get_info)* hsa_executable_get_info_fn;
|
||||
decltype(hsa_executable_global_variable_define)*
|
||||
hsa_executable_global_variable_define_fn;
|
||||
decltype(hsa_executable_agent_global_variable_define)*
|
||||
hsa_executable_agent_global_variable_define_fn;
|
||||
decltype(hsa_executable_readonly_variable_define)*
|
||||
hsa_executable_readonly_variable_define_fn;
|
||||
decltype(hsa_executable_validate)* hsa_executable_validate_fn;
|
||||
// Deprecated since v1.1.
|
||||
decltype(hsa_executable_get_symbol)* hsa_executable_get_symbol_fn;
|
||||
decltype(hsa_executable_symbol_get_info)* hsa_executable_symbol_get_info_fn;
|
||||
// Deprecated since v1.1.
|
||||
decltype(hsa_executable_iterate_symbols)* hsa_executable_iterate_symbols_fn;
|
||||
|
||||
//===--- Runtime Notifications ------------------------------------------===//
|
||||
|
||||
decltype(hsa_status_string)* hsa_status_string_fn;
|
||||
|
||||
//Start HSA v1.1 additions
|
||||
decltype(hsa_extension_get_name)* hsa_extension_get_name_fn;
|
||||
decltype(hsa_system_major_extension_supported)* hsa_system_major_extension_supported_fn;
|
||||
decltype(hsa_system_get_major_extension_table)* hsa_system_get_major_extension_table_fn;
|
||||
decltype(hsa_agent_major_extension_supported)* hsa_agent_major_extension_supported_fn;
|
||||
decltype(hsa_cache_get_info)* hsa_cache_get_info_fn;
|
||||
decltype(hsa_agent_iterate_caches)* hsa_agent_iterate_caches_fn;
|
||||
decltype(hsa_signal_silent_store_relaxed)* hsa_signal_silent_store_relaxed_fn;
|
||||
decltype(hsa_signal_silent_store_screlease)* hsa_signal_silent_store_screlease_fn;
|
||||
decltype(hsa_signal_group_create)* hsa_signal_group_create_fn;
|
||||
decltype(hsa_signal_group_destroy)* hsa_signal_group_destroy_fn;
|
||||
decltype(hsa_signal_group_wait_any_scacquire)* hsa_signal_group_wait_any_scacquire_fn;
|
||||
decltype(hsa_signal_group_wait_any_relaxed)* hsa_signal_group_wait_any_relaxed_fn;
|
||||
|
||||
//===--- Instruction Set Architecture - HSA v1.1 additions --------------===//
|
||||
|
||||
decltype(hsa_agent_iterate_isas)* hsa_agent_iterate_isas_fn;
|
||||
decltype(hsa_isa_get_info_alt)* hsa_isa_get_info_alt_fn;
|
||||
decltype(hsa_isa_get_exception_policies)* hsa_isa_get_exception_policies_fn;
|
||||
decltype(hsa_isa_get_round_method)* hsa_isa_get_round_method_fn;
|
||||
decltype(hsa_wavefront_get_info)* hsa_wavefront_get_info_fn;
|
||||
decltype(hsa_isa_iterate_wavefronts)* hsa_isa_iterate_wavefronts_fn;
|
||||
|
||||
//===--- Code Objects (deprecated) - HSA v1.1 additions -----------------===//
|
||||
|
||||
// Deprecated since v1.1.
|
||||
decltype(hsa_code_object_get_symbol_from_name)*
|
||||
hsa_code_object_get_symbol_from_name_fn;
|
||||
|
||||
//===--- Executable - HSA v1.1 additions --------------------------------===//
|
||||
|
||||
decltype(hsa_code_object_reader_create_from_file)*
|
||||
hsa_code_object_reader_create_from_file_fn;
|
||||
decltype(hsa_code_object_reader_create_from_memory)*
|
||||
hsa_code_object_reader_create_from_memory_fn;
|
||||
decltype(hsa_code_object_reader_destroy)* hsa_code_object_reader_destroy_fn;
|
||||
decltype(hsa_executable_create_alt)* hsa_executable_create_alt_fn;
|
||||
decltype(hsa_executable_load_program_code_object)*
|
||||
hsa_executable_load_program_code_object_fn;
|
||||
decltype(hsa_executable_load_agent_code_object)*
|
||||
hsa_executable_load_agent_code_object_fn;
|
||||
decltype(hsa_executable_validate_alt)* hsa_executable_validate_alt_fn;
|
||||
decltype(hsa_executable_get_symbol_by_name)*
|
||||
hsa_executable_get_symbol_by_name_fn;
|
||||
decltype(hsa_executable_iterate_agent_symbols)*
|
||||
hsa_executable_iterate_agent_symbols_fn;
|
||||
decltype(hsa_executable_iterate_program_symbols)*
|
||||
hsa_executable_iterate_program_symbols_fn;
|
||||
};
|
||||
|
||||
// Table to export HSA Apis from Core Runtime, Amd Extensions
|
||||
|
||||
@@ -710,6 +710,11 @@ typedef enum {
|
||||
|
||||
} hsa_ext_sampler_addressing_mode_t;
|
||||
|
||||
/**
|
||||
*@brief Fixed size container for address mode.
|
||||
*/
|
||||
typedef uint32_t hsa_ext_sampler_addressing_mode32_t;
|
||||
|
||||
/**
|
||||
* @brief Sampler coordinate modes. The enumeration values match the BRIG
|
||||
* BRIG_SAMPLER_COORD bit in BrigSamplerModifier.
|
||||
@@ -727,6 +732,11 @@ typedef enum {
|
||||
|
||||
} hsa_ext_sampler_coordinate_mode_t;
|
||||
|
||||
/**
|
||||
*@brief Fixed size container for coordinate mode.
|
||||
*/
|
||||
typedef uint32_t hsa_ext_sampler_coordinate_mode32_t;
|
||||
|
||||
/**
|
||||
* @brief Sampler filter modes. The enumeration values match the BRIG type
|
||||
* BrigSamplerFilter.
|
||||
@@ -747,6 +757,11 @@ typedef enum {
|
||||
|
||||
} hsa_ext_sampler_filter_mode_t;
|
||||
|
||||
/**
|
||||
*@brief Fixed size container for filter mode.
|
||||
*/
|
||||
typedef uint32_t hsa_ext_sampler_filter_mode32_t;
|
||||
|
||||
/**
|
||||
* @brief Implementation-independent sampler descriptor.
|
||||
*/
|
||||
@@ -754,18 +769,18 @@ typedef struct hsa_ext_sampler_descriptor_s {
|
||||
/**
|
||||
* Sampler coordinate mode describes the normalization of image coordinates.
|
||||
*/
|
||||
hsa_ext_sampler_coordinate_mode_t coordinate_mode;
|
||||
hsa_ext_sampler_coordinate_mode32_t coordinate_mode;
|
||||
|
||||
/**
|
||||
* Sampler filter type describes the type of sampling performed.
|
||||
*/
|
||||
hsa_ext_sampler_filter_mode_t filter_mode;
|
||||
hsa_ext_sampler_filter_mode32_t filter_mode;
|
||||
|
||||
/**
|
||||
* Sampler address mode describes the processing of out-of-range image
|
||||
* coordinates.
|
||||
*/
|
||||
hsa_ext_sampler_addressing_mode_t address_mode;
|
||||
hsa_ext_sampler_addressing_mode32_t address_mode;
|
||||
|
||||
} hsa_ext_sampler_descriptor_t;
|
||||
|
||||
@@ -828,7 +843,15 @@ enum {
|
||||
/**
|
||||
* Image size is not supported.
|
||||
*/
|
||||
HSA_EXT_STATUS_ERROR_IMAGE_SIZE_UNSUPPORTED = 0x3001
|
||||
HSA_EXT_STATUS_ERROR_IMAGE_SIZE_UNSUPPORTED = 0x3001,
|
||||
/**
|
||||
* Image pitch is not supported or invalid.
|
||||
*/
|
||||
HSA_EXT_STATUS_ERROR_IMAGE_PITCH_UNSUPPORTED = 0x3002,
|
||||
/**
|
||||
* Sampler descriptor is not supported or invalid.
|
||||
*/
|
||||
HSA_EXT_STATUS_ERROR_SAMPLER_DESCRIPTOR_UNSUPPORTED = 0x3003
|
||||
};
|
||||
|
||||
/**
|
||||
|
||||
@@ -135,11 +135,11 @@ void Loader::Destroy(Loader *loader)
|
||||
}
|
||||
|
||||
Executable* AmdHsaCodeLoader::CreateExecutable(
|
||||
hsa_profile_t profile, const char *options)
|
||||
hsa_profile_t profile, const char *options, hsa_default_float_rounding_mode_t default_float_rounding_mode)
|
||||
{
|
||||
WriterLockGuard<ReaderWriterLock> writer_lock(rw_lock_);
|
||||
|
||||
executables.push_back(new ExecutableImpl(profile, context, executables.size()));
|
||||
executables.push_back(new ExecutableImpl(profile, context, executables.size(), default_float_rounding_mode));
|
||||
return executables.back();
|
||||
}
|
||||
|
||||
@@ -372,6 +372,10 @@ bool SymbolImpl::GetInfo(hsa_symbol_info32_t symbol_info, void *value) {
|
||||
*((bool*)value) = is_definition;
|
||||
break;
|
||||
}
|
||||
case HSA_EXECUTABLE_SYMBOL_INFO_KERNEL_CALL_CONVENTION: {
|
||||
*((uint32_t*)value) = 0;
|
||||
break;
|
||||
}
|
||||
case HSA_EXECUTABLE_SYMBOL_INFO_KERNEL_OBJECT:
|
||||
case HSA_EXECUTABLE_SYMBOL_INFO_VARIABLE_ADDRESS: {
|
||||
if (!is_loaded) {
|
||||
@@ -525,15 +529,15 @@ bool VariableSymbol::GetInfo(hsa_symbol_info32_t symbol_info, void *value) {
|
||||
return true;
|
||||
}
|
||||
|
||||
bool LoadedCodeObjectImpl::GetInfo(amd_loaded_code_object_info_t attribute, void *value)
|
||||
bool LoadedCodeObjectImpl::GetInfo(hsa_loaded_code_object_info_t attribute, void *value)
|
||||
{
|
||||
assert(value);
|
||||
|
||||
switch (attribute) {
|
||||
case AMD_LOADED_CODE_OBJECT_INFO_ELF_IMAGE:
|
||||
case HSA_LOADED_CODE_OBJECT_INFO_ELF_IMAGE:
|
||||
((hsa_code_object_t*)value)->handle = reinterpret_cast<uint64_t>(elf_data);
|
||||
break;
|
||||
case AMD_LOADED_CODE_OBJECT_INFO_ELF_IMAGE_SIZE:
|
||||
case HSA_LOADED_CODE_OBJECT_INFO_ELF_IMAGE_SIZE:
|
||||
*((size_t*)value) = elf_size;
|
||||
break;
|
||||
default: {
|
||||
@@ -646,11 +650,16 @@ void Segment::Destroy()
|
||||
// ExecutableImpl. //
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
ExecutableImpl::ExecutableImpl(const hsa_profile_t &_profile, Context *context, size_t id)
|
||||
ExecutableImpl::ExecutableImpl(
|
||||
const hsa_profile_t &_profile,
|
||||
Context *context,
|
||||
size_t id,
|
||||
hsa_default_float_rounding_mode_t default_float_rounding_mode)
|
||||
: Executable()
|
||||
, profile_(_profile)
|
||||
, context_(context)
|
||||
, id_(id)
|
||||
, default_float_rounding_mode_(default_float_rounding_mode)
|
||||
, state_(HSA_EXECUTABLE_STATE_UNFROZEN)
|
||||
, program_allocation_segment(nullptr)
|
||||
{
|
||||
@@ -676,7 +685,6 @@ hsa_status_t ExecutableImpl::DefineProgramExternalVariable(
|
||||
{
|
||||
WriterLockGuard<ReaderWriterLock> writer_lock(rw_lock_);
|
||||
assert(name);
|
||||
assert(address);
|
||||
|
||||
if (HSA_EXECUTABLE_STATE_FROZEN == state_) {
|
||||
return HSA_STATUS_ERROR_FROZEN_EXECUTABLE;
|
||||
@@ -711,7 +719,6 @@ hsa_status_t ExecutableImpl::DefineAgentExternalVariable(
|
||||
{
|
||||
WriterLockGuard<ReaderWriterLock> writer_lock(rw_lock_);
|
||||
assert(name);
|
||||
assert(address);
|
||||
|
||||
if (HSA_EXECUTABLE_STATE_FROZEN == state_) {
|
||||
return HSA_STATUS_ERROR_FROZEN_EXECUTABLE;
|
||||
@@ -738,39 +745,41 @@ hsa_status_t ExecutableImpl::DefineAgentExternalVariable(
|
||||
return HSA_STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
bool ExecutableImpl::IsProgramSymbol(const char *symbol_name) {
|
||||
assert(symbol_name);
|
||||
|
||||
ReaderLockGuard<ReaderWriterLock> reader_lock(rw_lock_);
|
||||
return program_symbols_.find(std::string(symbol_name)) != program_symbols_.end();
|
||||
}
|
||||
|
||||
Symbol* ExecutableImpl::GetSymbol(
|
||||
const char *module_name,
|
||||
const char *symbol_name,
|
||||
hsa_agent_t agent,
|
||||
int32_t call_convention)
|
||||
const hsa_agent_t *agent)
|
||||
{
|
||||
ReaderLockGuard<ReaderWriterLock> reader_lock(rw_lock_);
|
||||
return this->GetSymbolInternal(module_name, symbol_name, agent, call_convention);
|
||||
return this->GetSymbolInternal(symbol_name, agent);
|
||||
}
|
||||
|
||||
Symbol* ExecutableImpl::GetSymbolInternal(
|
||||
const char *module_name,
|
||||
const char *symbol_name,
|
||||
hsa_agent_t agent,
|
||||
int32_t call_convention)
|
||||
const hsa_agent_t *agent)
|
||||
{
|
||||
assert(module_name);
|
||||
assert(symbol_name);
|
||||
|
||||
std::string mangled_name = std::string(symbol_name);
|
||||
if (mangled_name.empty()) {
|
||||
return nullptr;
|
||||
}
|
||||
if (!std::string(module_name).empty()) {
|
||||
mangled_name.insert(0, "::");
|
||||
mangled_name.insert(0, std::string(module_name));
|
||||
|
||||
if (!agent) {
|
||||
auto program_symbol = program_symbols_.find(mangled_name);
|
||||
if (program_symbol != program_symbols_.end()) {
|
||||
return program_symbol->second;
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
auto program_symbol = program_symbols_.find(mangled_name);
|
||||
if (program_symbol != program_symbols_.end()) {
|
||||
return program_symbol->second;
|
||||
}
|
||||
auto agent_symbol = agent_symbols_.find(std::make_pair(mangled_name, agent));
|
||||
auto agent_symbol = agent_symbols_.find(std::make_pair(mangled_name, *agent));
|
||||
if (agent_symbol != agent_symbols_.end()) {
|
||||
return agent_symbol->second;
|
||||
}
|
||||
@@ -801,9 +810,54 @@ hsa_status_t ExecutableImpl::IterateSymbols(
|
||||
return HSA_STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
hsa_status_t ExecutableImpl::IterateAgentSymbols(
|
||||
hsa_agent_t agent,
|
||||
hsa_status_t (*callback)(hsa_executable_t exec,
|
||||
hsa_agent_t agent,
|
||||
hsa_executable_symbol_t symbol,
|
||||
void *data),
|
||||
void *data) {
|
||||
ReaderLockGuard<ReaderWriterLock> reader_lock(rw_lock_);
|
||||
assert(callback);
|
||||
|
||||
for (auto &symbol_entry : agent_symbols_) {
|
||||
if (symbol_entry.second->GetAgent().handle != agent.handle) {
|
||||
continue;
|
||||
}
|
||||
|
||||
hsa_status_t status = callback(
|
||||
Executable::Handle(this), agent, Symbol::Handle(symbol_entry.second),
|
||||
data);
|
||||
if (status != HSA_STATUS_SUCCESS) {
|
||||
return status;
|
||||
}
|
||||
}
|
||||
|
||||
return HSA_STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
hsa_status_t ExecutableImpl::IterateProgramSymbols(
|
||||
hsa_status_t (*callback)(hsa_executable_t exec,
|
||||
hsa_executable_symbol_t symbol,
|
||||
void *data),
|
||||
void *data) {
|
||||
ReaderLockGuard<ReaderWriterLock> reader_lock(rw_lock_);
|
||||
assert(callback);
|
||||
|
||||
for (auto &symbol_entry : program_symbols_) {
|
||||
hsa_status_t status = callback(
|
||||
Executable::Handle(this), Symbol::Handle(symbol_entry.second), data);
|
||||
if (status != HSA_STATUS_SUCCESS) {
|
||||
return status;
|
||||
}
|
||||
}
|
||||
|
||||
return HSA_STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
hsa_status_t ExecutableImpl::IterateLoadedCodeObjects(
|
||||
hsa_status_t (*callback)(
|
||||
amd_loaded_code_object_t loaded_code_object,
|
||||
hsa_loaded_code_object_t loaded_code_object,
|
||||
void *data),
|
||||
void *data)
|
||||
{
|
||||
@@ -908,6 +962,11 @@ hsa_status_t ExecutableImpl::GetInfo(
|
||||
*((hsa_executable_state_t*)value) = state_;
|
||||
break;
|
||||
}
|
||||
case HSA_EXECUTABLE_INFO_DEFAULT_FLOAT_ROUNDING_MODE: {
|
||||
*((hsa_default_float_rounding_mode_t*)value) =
|
||||
default_float_rounding_mode_;
|
||||
break;
|
||||
}
|
||||
default: {
|
||||
return HSA_STATUS_ERROR_INVALID_ARGUMENT;
|
||||
}
|
||||
@@ -926,9 +985,10 @@ hsa_status_t ExecutableImpl::LoadCodeObject(
|
||||
hsa_agent_t agent,
|
||||
hsa_code_object_t code_object,
|
||||
const char *options,
|
||||
amd_loaded_code_object_t *loaded_code_object)
|
||||
hsa_loaded_code_object_t *loaded_code_object,
|
||||
bool load_legacy)
|
||||
{
|
||||
return LoadCodeObject(agent, code_object, 0, options, loaded_code_object);
|
||||
return LoadCodeObject(agent, code_object, 0, options, loaded_code_object, load_legacy);
|
||||
}
|
||||
|
||||
hsa_status_t ExecutableImpl::LoadCodeObject(
|
||||
@@ -936,7 +996,8 @@ hsa_status_t ExecutableImpl::LoadCodeObject(
|
||||
hsa_code_object_t code_object,
|
||||
size_t code_object_size,
|
||||
const char *options,
|
||||
amd_loaded_code_object_t *loaded_code_object)
|
||||
hsa_loaded_code_object_t *loaded_code_object,
|
||||
bool load_legacy)
|
||||
{
|
||||
WriterLockGuard<ReaderWriterLock> writer_lock(rw_lock_);
|
||||
if (HSA_EXECUTABLE_STATE_FROZEN == state_) {
|
||||
@@ -954,6 +1015,7 @@ hsa_status_t ExecutableImpl::LoadCodeObject(
|
||||
}
|
||||
|
||||
code.reset(new code::AmdHsaCode());
|
||||
load_legacy_ = load_legacy;
|
||||
|
||||
if (!code->InitAsHandle(code_object)) {
|
||||
return HSA_STATUS_ERROR_INVALID_CODE_OBJECT;
|
||||
@@ -984,14 +1046,14 @@ hsa_status_t ExecutableImpl::LoadCodeObject(
|
||||
hsa_isa_t objectsIsa = context_->IsaFromName(codeIsa.c_str());
|
||||
if (!objectsIsa.handle) { return HSA_STATUS_ERROR_INVALID_ISA_NAME; }
|
||||
|
||||
if (!context_->IsaSupportedByAgent(agent, objectsIsa)) { return HSA_STATUS_ERROR_INCOMPATIBLE_ARGUMENTS; }
|
||||
|
||||
uint32_t majorVersion, minorVersion;
|
||||
if (!code->GetNoteCodeObjectVersion(&majorVersion, &minorVersion)) {
|
||||
return HSA_STATUS_ERROR_INVALID_CODE_OBJECT;
|
||||
}
|
||||
|
||||
if (majorVersion != 1 && majorVersion != 2) { return HSA_STATUS_ERROR_INVALID_CODE_OBJECT; }
|
||||
if (agent.handle == 0 && majorVersion == 1) { return HSA_STATUS_ERROR_INVALID_AGENT; }
|
||||
if (agent.handle != 0 && !context_->IsaSupportedByAgent(agent, objectsIsa)) { return HSA_STATUS_ERROR_INCOMPATIBLE_ARGUMENTS; }
|
||||
|
||||
uint32_t codeHsailMajor;
|
||||
uint32_t codeHsailMinor;
|
||||
@@ -1084,7 +1146,11 @@ hsa_status_t ExecutableImpl::LoadSymbol(hsa_agent_t agent, code::Symbol* sym)
|
||||
|
||||
hsa_status_t ExecutableImpl::LoadDefinitionSymbol(hsa_agent_t agent, code::Symbol* sym)
|
||||
{
|
||||
if (sym->IsAgent()) {
|
||||
bool isAgent = sym->IsAgent();
|
||||
if (!load_legacy_) {
|
||||
isAgent = agent.handle == 0 ? false : true;
|
||||
}
|
||||
if (isAgent) {
|
||||
auto agent_symbol = agent_symbols_.find(std::make_pair(sym->Name(), agent));
|
||||
if (agent_symbol != agent_symbols_.end()) {
|
||||
// TODO(spec): this is not spec compliant.
|
||||
@@ -1164,7 +1230,7 @@ hsa_status_t ExecutableImpl::LoadDefinitionSymbol(hsa_agent_t agent, code::Symbo
|
||||
return HSA_STATUS_ERROR;
|
||||
}
|
||||
assert(symbol);
|
||||
if (sym->IsAgent()) {
|
||||
if (isAgent) {
|
||||
agent_symbols_.insert(std::make_pair(std::make_pair(sym->Name(), agent), symbol));
|
||||
} else {
|
||||
program_symbols_.insert(std::make_pair(sym->Name(), symbol));
|
||||
@@ -1285,11 +1351,11 @@ hsa_status_t ExecutableImpl::ApplyStaticRelocation(hsa_agent_t agent, amd::hsa::
|
||||
if (!addr) { return HSA_STATUS_ERROR_INVALID_CODE_OBJECT; }
|
||||
break;
|
||||
case STT_COMMON: {
|
||||
hsa_agent_t sagent = agent;
|
||||
hsa_agent_t *sagent = &agent;
|
||||
if (STA_AMDGPU_HSA_GLOBAL_PROGRAM == ELF64_ST_AMDGPU_ALLOCATION(sym->other())) {
|
||||
sagent.handle = 0;
|
||||
sagent = nullptr;
|
||||
}
|
||||
SymbolImpl* esym = (SymbolImpl*) GetSymbolInternal("", sym->name().c_str(), sagent, 0);
|
||||
SymbolImpl* esym = (SymbolImpl*) GetSymbolInternal(sym->name().c_str(), sagent);
|
||||
if (!esym) { return HSA_STATUS_ERROR_VARIABLE_UNDEFINED; }
|
||||
addr = esym->address;
|
||||
break;
|
||||
|
||||
@@ -94,6 +94,10 @@ public:
|
||||
uint64_t address;
|
||||
hsa_agent_t agent;
|
||||
|
||||
hsa_agent_t GetAgent() override {
|
||||
return agent;
|
||||
}
|
||||
|
||||
protected:
|
||||
SymbolImpl(const bool &_is_loaded,
|
||||
const hsa_symbol_kind_t &_kind,
|
||||
@@ -253,7 +257,7 @@ public:
|
||||
size_t ElfSize() const { return elf_size; }
|
||||
std::vector<Segment*>& LoadedSegments() { return loaded_segments; }
|
||||
|
||||
bool GetInfo(amd_loaded_code_object_info_t attribute, void *value) override;
|
||||
bool GetInfo(hsa_loaded_code_object_info_t attribute, void *value) override;
|
||||
|
||||
hsa_status_t IterateLoadedSegments(
|
||||
hsa_status_t (*callback)(
|
||||
@@ -349,7 +353,11 @@ public:
|
||||
return state_;
|
||||
}
|
||||
|
||||
ExecutableImpl(const hsa_profile_t &_profile, Context *context, size_t id);
|
||||
ExecutableImpl(
|
||||
const hsa_profile_t &_profile,
|
||||
Context *context,
|
||||
size_t id,
|
||||
hsa_default_float_rounding_mode_t default_float_rounding_mode);
|
||||
|
||||
~ExecutableImpl();
|
||||
|
||||
@@ -368,14 +376,16 @@ public:
|
||||
hsa_agent_t agent,
|
||||
hsa_code_object_t code_object,
|
||||
const char *options,
|
||||
amd_loaded_code_object_t *loaded_code_object);
|
||||
hsa_loaded_code_object_t *loaded_code_object,
|
||||
bool load_legacy = true);
|
||||
|
||||
hsa_status_t LoadCodeObject(
|
||||
hsa_agent_t agent,
|
||||
hsa_code_object_t code_object,
|
||||
size_t code_object_size,
|
||||
const char *options,
|
||||
amd_loaded_code_object_t *loaded_code_object);
|
||||
hsa_loaded_code_object_t *loaded_code_object,
|
||||
bool load_legacy = true);
|
||||
|
||||
hsa_status_t Freeze(const char *options);
|
||||
|
||||
@@ -386,18 +396,36 @@ public:
|
||||
return HSA_STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
/// @note needed for hsa v1.0.
|
||||
/// @todo remove during loader refactoring.
|
||||
bool IsProgramSymbol(const char *symbol_name) override;
|
||||
|
||||
Symbol* GetSymbol(
|
||||
const char *module_name,
|
||||
const char *symbol_name,
|
||||
hsa_agent_t agent,
|
||||
int32_t call_convention);
|
||||
const hsa_agent_t *agent) override;
|
||||
|
||||
hsa_status_t IterateSymbols(
|
||||
iterate_symbols_f callback, void *data);
|
||||
|
||||
/// @since hsa v1.1.
|
||||
hsa_status_t IterateAgentSymbols(
|
||||
hsa_agent_t agent,
|
||||
hsa_status_t (*callback)(hsa_executable_t exec,
|
||||
hsa_agent_t agent,
|
||||
hsa_executable_symbol_t symbol,
|
||||
void *data),
|
||||
void *data) override;
|
||||
|
||||
/// @since hsa v1.1.
|
||||
hsa_status_t IterateProgramSymbols(
|
||||
hsa_status_t (*callback)(hsa_executable_t exec,
|
||||
hsa_executable_symbol_t symbol,
|
||||
void *data),
|
||||
void *data) override;
|
||||
|
||||
hsa_status_t IterateLoadedCodeObjects(
|
||||
hsa_status_t (*callback)(
|
||||
amd_loaded_code_object_t loaded_code_object,
|
||||
hsa_loaded_code_object_t loaded_code_object,
|
||||
void *data),
|
||||
void *data);
|
||||
|
||||
@@ -424,12 +452,11 @@ private:
|
||||
ExecutableImpl& operator=(const ExecutableImpl &e);
|
||||
|
||||
std::unique_ptr<amd::hsa::code::AmdHsaCode> code;
|
||||
bool load_legacy_;
|
||||
|
||||
Symbol* GetSymbolInternal(
|
||||
const char *module_name,
|
||||
const char *symbol_name,
|
||||
hsa_agent_t agent,
|
||||
int32_t call_convention);
|
||||
const hsa_agent_t *agent);
|
||||
|
||||
hsa_status_t LoadSegment(hsa_agent_t agent, code::Segment* s, uint32_t majorVersion, uint16_t machine);
|
||||
hsa_status_t LoadSegmentV1(hsa_agent_t agent, amd::hsa::code::Segment* seg);
|
||||
@@ -454,6 +481,7 @@ private:
|
||||
hsa_profile_t profile_;
|
||||
Context *context_;
|
||||
const size_t id_;
|
||||
hsa_default_float_rounding_mode_t default_float_rounding_mode_;
|
||||
hsa_executable_state_t state_;
|
||||
|
||||
ProgramSymbolMap program_symbols_;
|
||||
@@ -475,7 +503,10 @@ public:
|
||||
|
||||
Context* GetContext() const { return context; }
|
||||
|
||||
Executable* CreateExecutable(hsa_profile_t profile, const char *options) override;
|
||||
Executable* CreateExecutable(
|
||||
hsa_profile_t profile,
|
||||
const char *options,
|
||||
hsa_default_float_rounding_mode_t default_float_rounding_mode = HSA_DEFAULT_FLOAT_ROUNDING_MODE_DEFAULT) override;
|
||||
|
||||
void DestroyExecutable(Executable *executable) override;
|
||||
|
||||
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur