AI/rocm-systems
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'origin/pghafari/hip-vdi' into lmoriche/amd-master-next

Browse Source 
Change-Id: I22c145d39f430ca571a981687bcb034ea6e3b8a2


[ROCm/hip commit: a8b81e96b4]
This commit is contained in:
Laurent Morichetti
2020-01-29 16:03:14 -08:00
parent cbd1b27c5e
commit bc78a8529d
37 changed files with 13912 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files
projects/hip/CMakeLists.txt
+81 -16
View File
@@ -1,5 +1,10 @@
cmake_minimum_required(VERSION 3.4.3)
project(hip)
# sample command for hip-vdi, you'll need to have vdi installed
# cmake -DHIP_COMPILER=clang -DHIP_PLATFORM=vdi ..
# cmake -DHIP_COMPILER=clang -DHIP_PLATFORM=vdi -DVDI_DIR=/extra/lmoriche/hip-vdi/vdi -DOPENCL_DIR=/extra/lmoriche/clients/lmoriche_opencl_dev2/drivers/opencl/api/opencl -DLIBVDI_STATIC_DIR=/extra/lmoriche/hip-vdi/build/vdi ..
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
#############################
# Options
@@ -104,12 +109,17 @@ add_to_config(_buildInfo HIP_COMPILER)
# Determine HIP_RUNTIME
# Either HCC or VDI; default is HCC
if(NOT DEFINED ENV{HIP_RUNTIME})
if(HIP_PLATFORM STREQUAL "hcc")
set(HIP_RUNTIME "HCC" CACHE STRING "HIP Runtime")
else()
set(HIP_RUNTIME $ENV{HIP_RUNTIME} CACHE STRING "HIP Runtime")
elseif (HIP_PLATFORM STREQUAL "vdi")
set(HIP_RUNTIME "VDI" CACHE STRING "HIP Runtime")
endif()
endif()
add_to_config(_buildInfo HIP_RUNTIME)
if(HIP_PLATFORM STREQUAL "vdi")
set(USE_PROF_API "1")
endif()
# If HIP_PLATFORM is hcc, we need HCC_HOME and HSA_PATH to be defined
if(HIP_PLATFORM STREQUAL "hcc")
@@ -213,6 +223,8 @@ add_to_config(_buildInfo COMPILE_HIP_ATP_MARKER)
# Profiling API support
#############################
# Generate profiling API macros/structures header
if(HIP_PLATFORM STREQUAL "hcc")
if(USE_PROF_API EQUAL 1)
set(PROF_API_STR "${CMAKE_CURRENT_SOURCE_DIR}/include/hip/hcc_detail/hip_prof_str.h")
set(PROF_API_HDR "${CMAKE_CURRENT_SOURCE_DIR}/include/hip/hcc_detail/hip_runtime_api.h")
set(PROF_API_SRC "${CMAKE_CURRENT_SOURCE_DIR}/src")
@@ -224,7 +236,6 @@ execute_process(COMMAND sh -c "rm -f ${PROF_API_STR}; ${PROF_API_CMD}")
set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS ${PROF_API_GEN} ${PROF_API_HDR} ${PROF_API_STR})
# Enable profiling API
if(USE_PROF_API EQUAL 1)
find_path(PROF_API_HEADER_DIR prof_protocol.h
HINTS
${PROF_API_HEADER_PATH}
@@ -241,6 +252,7 @@ if(USE_PROF_API EQUAL 1)
MESSAGE(STATUS "Profiling API: ${PROF_API_HEADER_DIR}")
endif()
endif()
endif()
#############################
# Build steps
@@ -258,10 +270,40 @@ endif()
# Build LPL an CA (fat binary generation / fat binary decomposition tools) if
# platform is hcc; do this before the ugly hijacking of the compiler, since no
# HC code is involved.
if (HIP_PLATFORM STREQUAL "hcc")
add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/lpl_ca)
endif ()
#if (HIP_PLATFORM STREQUAL "hcc")
# add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/lpl_ca)
#endif ()
if(HIP_PLATFORM STREQUAL "vdi")
# Determine HSA_PATH
if(NOT DEFINED HSA_PATH)
if(NOT DEFINED ENV{HSA_PATH})
set(HSA_PATH "/opt/rocm/hsa" CACHE PATH "Path to which HSA runtime has been installed")
else()
set(HSA_PATH $ENV{HSA_PATH} CACHE PATH "Path to which HSA runtime has been installed")
endif()
endif()
if(IS_ABSOLUTE ${HSA_PATH} AND EXISTS ${HSA_PATH} AND IS_DIRECTORY ${HSA_PATH})
message(STATUS "Looking for HSA runtime in: " ${HSA_PATH})
else()
message(FATAL_ERROR "Don't know where to find HSA runtime. Please specify absolute path using -DHSA_PATH")
endif()
include_directories(${PROJECT_SOURCE_DIR}/include)
add_subdirectory(vdi)
file(WRITE "${PROJECT_BINARY_DIR}/.hipInfo" ${_buildInfo})
# set(VDI_CXX_FLAGS "-hc -fno-gpu-rdc --amdgpu-target=gfx803 --amdgpu-target=gfx900 --amdgpu-target=gfx906 --amdgpu-target=gfx908 ")
set(HIP_VDI_BUILD_FLAGS "${HIP_VDI_BUILD_FLAGS} -fPIC ${VDI_CXX_FLAGS} -I${HSA_PATH}/include")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${HIP_VDI_BUILD_FLAGS}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${HIP_VDI_BUILD_FLAGS}")
set(HCC_CXX_FLAGS "-hc -fno-gpu-rdc --amdgpu-target=gfx803 --amdgpu-target=gfx900 --amdgpu-target=gfx906 --amdgpu-target=gfx908 ")
set(HIP_HCC_BUILD_FLAGS "${HIP_HCC_BUILD_FLAGS} -fPIC ${HCC_CXX_FLAGS} -I${HSA_PATH}/include")
endif()
message(STATUS "\nHSA runtime in: " ${HSA_PATH})
# Build hip_hcc if platform is hcc
if(HIP_PLATFORM STREQUAL "hcc")
include_directories(${PROJECT_SOURCE_DIR}/include)
@@ -341,7 +383,7 @@ if(HIP_PLATFORM STREQUAL "hcc")
target_include_directories(
hiprtc SYSTEM
PRIVATE ${PROJECT_SOURCE_DIR}/include ${HSA_PATH}/include)
endif()
endif()
set_target_properties(hip_hcc PROPERTIES CXX_VISIBILITY_PRESET hidden)
set_target_properties(hip_hcc PROPERTIES VISIBILITY_INLINES_HIDDEN 1)
@@ -376,6 +418,7 @@ if(HIP_PLATFORM STREQUAL "hcc")
file(WRITE "${PROJECT_BINARY_DIR}/.hipInfo" ${_buildInfo})
endif()
add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/lpl_ca)
# Generate .hipVersion
file(WRITE "${PROJECT_BINARY_DIR}/.hipVersion" ${_versionInfo})
@@ -410,10 +453,11 @@ if(HIP_PLATFORM STREQUAL "hcc")
install(TARGETS hip_hcc_static hip_hcc DESTINATION lib)
endif()
# Install .hipInfo
install(FILES ${PROJECT_BINARY_DIR}/.hipInfo DESTINATION lib)
endif()
# Install .hipInfo
install(FILES ${PROJECT_BINARY_DIR}/.hipInfo DESTINATION lib)
# Install .hipVersion
install(FILES ${PROJECT_BINARY_DIR}/.hipVersion DESTINATION bin)
@@ -433,6 +477,9 @@ endif()
if(HIP_PLATFORM STREQUAL "hcc")
install(TARGETS hip_hcc_static hip_hcc host device EXPORT hip-targets DESTINATION ${LIB_INSTALL_DIR})
install(EXPORT hip-targets DESTINATION ${CONFIG_PACKAGE_INSTALL_DIR} NAMESPACE hip::)
elseif( HIP_PLATFORM STREQUAL "vdi")
# install(TARGETS hip_on_vdi host device EXPORT hip-targets DESTINATION ${LIB_INSTALL_DIR})
endif()
include(CMakePackageConfigHelpers)
if(HIP_COMPILER STREQUAL "hcc")
@@ -463,13 +510,12 @@ if(HIP_PLATFORM STREQUAL "hcc")
DESTINATION
${CONFIG_PACKAGE_INSTALL_DIR}
)
endif()
#############################
# Packaging steps
#############################
# Package: hip_base
set(BUILD_DIR ${CMAKE_CURRENT_BINARY_DIR}/packages/hip_base)
set(BUILD_DIR ${CMAKE_CURRENT_BINARY_DIR}/packages/hip-base)
configure_file(packaging/hip-base.txt ${BUILD_DIR}/CMakeLists.txt @ONLY)
configure_file(packaging/hip-base.postinst ${BUILD_DIR}/postinst @ONLY)
configure_file(packaging/hip-base.prerm ${BUILD_DIR}/prerm @ONLY)
@@ -488,6 +534,8 @@ if (BUILD_HIPIFY_CLANG)
add_dependencies(pkg_hip_base hipify-clang)
endif()
if(HIP_PLATFORM STREQUAL "hcc")
message("HCC Package\n")
# Package: hip_hcc
set(BUILD_DIR ${CMAKE_CURRENT_BINARY_DIR}/packages/hip_hcc)
configure_file(packaging/hip-hcc.txt ${BUILD_DIR}/CMakeLists.txt @ONLY)
@@ -501,12 +549,11 @@ add_custom_target(pkg_hip_hcc COMMAND ${CMAKE_COMMAND} .
COMMAND cp *.tar.gz ${PROJECT_BINARY_DIR}
WORKING_DIRECTORY ${BUILD_DIR}
DEPENDS hip_hcc hip_hcc_static hiprtc)
endif()
# Package: hip_nvcc
set(BUILD_DIR ${CMAKE_CURRENT_BINARY_DIR}/packages/hip_nvcc)
set(BUILD_DIR ${CMAKE_CURRENT_BINARY_DIR}/packages/hip-nvcc)
configure_file(packaging/hip-nvcc.txt ${BUILD_DIR}/CMakeLists.txt @ONLY)
configure_file(packaging/hip-nvcc.postinst ${BUILD_DIR}/postinst @ONLY)
configure_file(packaging/hip-nvcc.prerm ${BUILD_DIR}/prerm @ONLY)
add_custom_target(pkg_hip_nvcc COMMAND ${CMAKE_COMMAND} .
COMMAND rm -rf *.deb *.rpm *.tar.gz
COMMAND make package
@@ -516,7 +563,7 @@ add_custom_target(pkg_hip_nvcc COMMAND ${CMAKE_COMMAND} .
WORKING_DIRECTORY ${BUILD_DIR})
# Package: hip_doc
set(BUILD_DIR ${CMAKE_CURRENT_BINARY_DIR}/packages/hip_doc)
set(BUILD_DIR ${CMAKE_CURRENT_BINARY_DIR}/packages/hip-doc)
configure_file(packaging/hip-doc.txt ${BUILD_DIR}/CMakeLists.txt @ONLY)
add_custom_target(pkg_hip_doc COMMAND ${CMAKE_COMMAND} .
COMMAND rm -rf *.deb *.rpm *.tar.gz
@@ -537,6 +584,16 @@ add_custom_target(pkg_hip_samples COMMAND ${CMAKE_COMMAND} .
COMMAND cp *.tar.gz ${PROJECT_BINARY_DIR}
WORKING_DIRECTORY ${BUILD_DIR})
set(BUILD_DIR ${CMAKE_CURRENT_BINARY_DIR}/vdi)
configure_file(packaging/hip-vdi.txt ${BUILD_DIR}/CMakeLists.txt @ONLY)
add_custom_target(hip_on_vdi COMMAND ${CMAKE_COMMAND} .
COMMAND rm -rf *.deb *.rpm *.tar.gz
COMMAND make package
COMMAND cp *.deb ${PROJECT_BINARY_DIR}
COMMAND cp *.rpm ${PROJECT_BINARY_DIR}
COMMAND cp *.tar.gz ${PROJECT_BINARY_DIR}
WORKING_DIRECTORY ${BUILD_DIR} )
# Package: all
if(POLICY CMP0037)
cmake_policy(PUSH)
@@ -546,10 +603,18 @@ file(GENERATE OUTPUT ${PROJECT_BINARY_DIR}/fixnames
CONTENT "pwd; for i in *.deb; do mv \"\$i\" \"\${i/.deb/-amd64.deb}\" ; done
for i in *.rpm ; do mv \$i \${i/.rpm/.x86_64.rpm} ; done
")
add_custom_target(package
if(HIP_PLATFORM STREQUAL "hcc")
add_custom_target(package
COMMAND bash ${PROJECT_BINARY_DIR}/fixnames
WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
DEPENDS pkg_hip_base pkg_hip_hcc pkg_hip_nvcc pkg_hip_doc pkg_hip_samples)
elseif(HIP_PLATFORM STREQUAL "vdi")
add_custom_target(package
COMMAND bash ${PROJECT_BINARY_DIR}/fixnames
WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
DEPENDS pkg_hip_base hip_on_vdi pkg_hip_nvcc pkg_hip_doc pkg_hip_samples)
endif()
if(POLICY CMP0037)
cmake_policy(POP)
endif()
projects/hip/amdocl/CL/cl.h
+1469
View File
File diff suppressed because it is too large Load Diff
projects/hip/amdocl/CL/cl_egl.h
+136
View File
@@ -0,0 +1,136 @@
/*******************************************************************************
* Copyright (c) 2008-2015 The Khronos Group Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and/or associated documentation files (the
* "Materials"), to deal in the Materials without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Materials, and to
* permit persons to whom the Materials are furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Materials.
*
* MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
* KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
* SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
* https://www.khronos.org/registry/
*
* THE MATERIALS ARE 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 AUTHORS 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
* MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
******************************************************************************/
#ifndef __OPENCL_CL_EGL_H
#define __OPENCL_CL_EGL_H
#ifdef __APPLE__
#else
#include <CL/cl.h>
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* Command type for events created with clEnqueueAcquireEGLObjectsKHR */
#define CL_COMMAND_EGL_FENCE_SYNC_OBJECT_KHR 0x202F
#define CL_COMMAND_ACQUIRE_EGL_OBJECTS_KHR 0x202D
#define CL_COMMAND_RELEASE_EGL_OBJECTS_KHR 0x202E
/* Error type for clCreateFromEGLImageKHR */
#define CL_INVALID_EGL_OBJECT_KHR -1093
#define CL_EGL_RESOURCE_NOT_ACQUIRED_KHR -1092
/* CLeglImageKHR is an opaque handle to an EGLImage */
typedef void* CLeglImageKHR;
/* CLeglDisplayKHR is an opaque handle to an EGLDisplay */
typedef void* CLeglDisplayKHR;
/* CLeglSyncKHR is an opaque handle to an EGLSync object */
typedef void* CLeglSyncKHR;
/* properties passed to clCreateFromEGLImageKHR */
typedef intptr_t cl_egl_image_properties_khr;
#define cl_khr_egl_image 1
extern CL_API_ENTRY cl_mem CL_API_CALL
clCreateFromEGLImageKHR(cl_context /* context */,
CLeglDisplayKHR /* egldisplay */,
CLeglImageKHR /* eglimage */,
cl_mem_flags /* flags */,
const cl_egl_image_properties_khr * /* properties */,
cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
typedef CL_API_ENTRY cl_mem (CL_API_CALL *clCreateFromEGLImageKHR_fn)(
cl_context context,
CLeglDisplayKHR egldisplay,
CLeglImageKHR eglimage,
cl_mem_flags flags,
const cl_egl_image_properties_khr * properties,
cl_int * errcode_ret);
extern CL_API_ENTRY cl_int CL_API_CALL
clEnqueueAcquireEGLObjectsKHR(cl_command_queue /* command_queue */,
cl_uint /* num_objects */,
const cl_mem * /* mem_objects */,
cl_uint /* num_events_in_wait_list */,
const cl_event * /* event_wait_list */,
cl_event * /* event */) CL_API_SUFFIX__VERSION_1_0;
typedef CL_API_ENTRY cl_int (CL_API_CALL *clEnqueueAcquireEGLObjectsKHR_fn)(
cl_command_queue command_queue,
cl_uint num_objects,
const cl_mem * mem_objects,
cl_uint num_events_in_wait_list,
const cl_event * event_wait_list,
cl_event * event);
extern CL_API_ENTRY cl_int CL_API_CALL
clEnqueueReleaseEGLObjectsKHR(cl_command_queue /* command_queue */,
cl_uint /* num_objects */,
const cl_mem * /* mem_objects */,
cl_uint /* num_events_in_wait_list */,
const cl_event * /* event_wait_list */,
cl_event * /* event */) CL_API_SUFFIX__VERSION_1_0;
typedef CL_API_ENTRY cl_int (CL_API_CALL *clEnqueueReleaseEGLObjectsKHR_fn)(
cl_command_queue command_queue,
cl_uint num_objects,
const cl_mem * mem_objects,
cl_uint num_events_in_wait_list,
const cl_event * event_wait_list,
cl_event * event);
#define cl_khr_egl_event 1
extern CL_API_ENTRY cl_event CL_API_CALL
clCreateEventFromEGLSyncKHR(cl_context /* context */,
CLeglSyncKHR /* sync */,
CLeglDisplayKHR /* display */,
cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
typedef CL_API_ENTRY cl_event (CL_API_CALL *clCreateEventFromEGLSyncKHR_fn)(
cl_context context,
CLeglSyncKHR sync,
CLeglDisplayKHR display,
cl_int * errcode_ret);
#ifdef __cplusplus
}
#endif
#endif /* __OPENCL_CL_EGL_H */
projects/hip/amdocl/CL/cl_ext.h
+853
View File
@@ -0,0 +1,853 @@
/*******************************************************************************
* Copyright (c) 2008-2015 The Khronos Group Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and/or associated documentation files (the
* "Materials"), to deal in the Materials without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Materials, and to
* permit persons to whom the Materials are furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Materials.
*
* MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
* KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
* SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
* https://www.khronos.org/registry/
*
* THE MATERIALS ARE 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 AUTHORS 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
* MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
******************************************************************************/
/* $Revision: 11928 $ on $Date: 2010-07-13 09:04:56 -0700 (Tue, 13 Jul 2010) $ */
/* cl_ext.h contains OpenCL extensions which don't have external */
/* (OpenGL, D3D) dependencies. */
#ifndef __CL_EXT_H
#define __CL_EXT_H
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __APPLE__
#include <OpenCL/cl.h>
#include <AvailabilityMacros.h>
#else
#include <CL/cl.h>
#endif
/* cl_khr_fp16 extension - no extension #define since it has no functions */
#define CL_DEVICE_HALF_FP_CONFIG 0x1033
/* Memory object destruction
*
* Apple extension for use to manage externally allocated buffers used with cl_mem objects with CL_MEM_USE_HOST_PTR
*
* Registers a user callback function that will be called when the memory object is deleted and its resources
* freed. Each call to clSetMemObjectCallbackFn registers the specified user callback function on a callback
* stack associated with memobj. The registered user callback functions are called in the reverse order in
* which they were registered. The user callback functions are called and then the memory object is deleted
* and its resources freed. This provides a mechanism for the application (and libraries) using memobj to be
* notified when the memory referenced by host_ptr, specified when the memory object is created and used as
* the storage bits for the memory object, can be reused or freed.
*
* The application may not call CL api's with the cl_mem object passed to the pfn_notify.
*
* Please check for the "cl_APPLE_SetMemObjectDestructor" extension using clGetDeviceInfo(CL_DEVICE_EXTENSIONS)
* before using.
*/
#define cl_APPLE_SetMemObjectDestructor 1
cl_int CL_API_ENTRY clSetMemObjectDestructorAPPLE( cl_mem /* memobj */,
void (* /*pfn_notify*/)( cl_mem /* memobj */, void* /*user_data*/),
void * /*user_data */ ) CL_EXT_SUFFIX__VERSION_1_0;
/* Context Logging Functions
*
* The next three convenience functions are intended to be used as the pfn_notify parameter to clCreateContext().
* Please check for the "cl_APPLE_ContextLoggingFunctions" extension using clGetDeviceInfo(CL_DEVICE_EXTENSIONS)
* before using.
*
* clLogMessagesToSystemLog fowards on all log messages to the Apple System Logger
*/
#define cl_APPLE_ContextLoggingFunctions 1
extern void CL_API_ENTRY clLogMessagesToSystemLogAPPLE( const char * /* errstr */,
const void * /* private_info */,
size_t /* cb */,
void * /* user_data */ ) CL_EXT_SUFFIX__VERSION_1_0;
/* clLogMessagesToStdout sends all log messages to the file descriptor stdout */
extern void CL_API_ENTRY clLogMessagesToStdoutAPPLE( const char * /* errstr */,
const void * /* private_info */,
size_t /* cb */,
void * /* user_data */ ) CL_EXT_SUFFIX__VERSION_1_0;
/* clLogMessagesToStderr sends all log messages to the file descriptor stderr */
extern void CL_API_ENTRY clLogMessagesToStderrAPPLE( const char * /* errstr */,
const void * /* private_info */,
size_t /* cb */,
void * /* user_data */ ) CL_EXT_SUFFIX__VERSION_1_0;
/************************
* cl_khr_icd extension *
************************/
#define cl_khr_icd 1
/* cl_platform_info */
#define CL_PLATFORM_ICD_SUFFIX_KHR 0x0920
/* Additional Error Codes */
#define CL_PLATFORM_NOT_FOUND_KHR -1001
extern CL_API_ENTRY cl_int CL_API_CALL
clIcdGetPlatformIDsKHR(cl_uint /* num_entries */,
cl_platform_id * /* platforms */,
cl_uint * /* num_platforms */);
typedef CL_API_ENTRY cl_int (CL_API_CALL *clIcdGetPlatformIDsKHR_fn)(
cl_uint /* num_entries */,
cl_platform_id * /* platforms */,
cl_uint * /* num_platforms */);
/* Extension: cl_khr_image2D_buffer
*
* This extension allows a 2D image to be created from a cl_mem buffer without a copy.
* The type associated with a 2D image created from a buffer in an OpenCL program is image2d_t.
* Both the sampler and sampler-less read_image built-in functions are supported for 2D images
* and 2D images created from a buffer. Similarly, the write_image built-ins are also supported
* for 2D images created from a buffer.
*
* When the 2D image from buffer is created, the client must specify the width,
* height, image format (i.e. channel order and channel data type) and optionally the row pitch
*
* The pitch specified must be a multiple of CL_DEVICE_IMAGE_PITCH_ALIGNMENT pixels.
* The base address of the buffer must be aligned to CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT pixels.
*/
/*************************************
* cl_khr_initalize_memory extension *
*************************************/
#define CL_CONTEXT_MEMORY_INITIALIZE_KHR 0x2030
/**************************************
* cl_khr_terminate_context extension *
**************************************/
#define CL_DEVICE_TERMINATE_CAPABILITY_KHR 0x2031
#define CL_CONTEXT_TERMINATE_KHR 0x2032
#define cl_khr_terminate_context 1
extern CL_API_ENTRY cl_int CL_API_CALL clTerminateContextKHR(cl_context /* context */) CL_EXT_SUFFIX__VERSION_1_2;
typedef CL_API_ENTRY cl_int (CL_API_CALL *clTerminateContextKHR_fn)(cl_context /* context */) CL_EXT_SUFFIX__VERSION_1_2;
/*
* Extension: cl_khr_spir
*
* This extension adds support to create an OpenCL program object from a
* Standard Portable Intermediate Representation (SPIR) instance
*/
#define CL_DEVICE_SPIR_VERSIONS 0x40E0
#define CL_PROGRAM_BINARY_TYPE_INTERMEDIATE 0x40E1
/******************************************
* cl_nv_device_attribute_query extension *
******************************************/
/* cl_nv_device_attribute_query extension - no extension #define since it has no functions */
#define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
#define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
#define CL_DEVICE_REGISTERS_PER_BLOCK_NV 0x4002
#define CL_DEVICE_WARP_SIZE_NV 0x4003
#define CL_DEVICE_GPU_OVERLAP_NV 0x4004
#define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
#define CL_DEVICE_INTEGRATED_MEMORY_NV 0x4006
/*********************************
* cl_amd_device_memory_flags *
*********************************/
#define cl_amd_device_memory_flags 1
#define CL_MEM_USE_PERSISTENT_MEM_AMD (1 << 6) // Alloc from GPU's CPU visible heap
/* cl_device_info */
#define CL_DEVICE_MAX_ATOMIC_COUNTERS_EXT 0x4032
/*********************************
* cl_amd_device_attribute_query *
*********************************/
#define CL_DEVICE_PROFILING_TIMER_OFFSET_AMD 0x4036
#define CL_DEVICE_TOPOLOGY_AMD 0x4037
#define CL_DEVICE_BOARD_NAME_AMD 0x4038
#define CL_DEVICE_GLOBAL_FREE_MEMORY_AMD 0x4039
#define CL_DEVICE_SIMD_PER_COMPUTE_UNIT_AMD 0x4040
#define CL_DEVICE_SIMD_WIDTH_AMD 0x4041
#define CL_DEVICE_SIMD_INSTRUCTION_WIDTH_AMD 0x4042
#define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
#define CL_DEVICE_GLOBAL_MEM_CHANNELS_AMD 0x4044
#define CL_DEVICE_GLOBAL_MEM_CHANNEL_BANKS_AMD 0x4045
#define CL_DEVICE_GLOBAL_MEM_CHANNEL_BANK_WIDTH_AMD 0x4046
#define CL_DEVICE_LOCAL_MEM_SIZE_PER_COMPUTE_UNIT_AMD 0x4047
#define CL_DEVICE_LOCAL_MEM_BANKS_AMD 0x4048
#define CL_DEVICE_THREAD_TRACE_SUPPORTED_AMD 0x4049
#define CL_DEVICE_GFXIP_MAJOR_AMD 0x404A
#define CL_DEVICE_GFXIP_MINOR_AMD 0x404B
#define CL_DEVICE_AVAILABLE_ASYNC_QUEUES_AMD 0x404C
#define CL_DEVICE_PREFERRED_WORK_GROUP_SIZE_AMD 0x4030
#define CL_DEVICE_MAX_WORK_GROUP_SIZE_AMD 0x4031
#define CL_DEVICE_PREFERRED_CONSTANT_BUFFER_SIZE_AMD 0x4033
#define CL_DEVICE_PCIE_ID_AMD 0x4034
typedef union
{
struct { cl_uint type; cl_uint data[5]; } raw;
struct { cl_uint type; cl_uchar unused[17]; cl_uchar bus; cl_uchar device; cl_uchar function; } pcie;
} cl_device_topology_amd;
#define CL_DEVICE_TOPOLOGY_TYPE_PCIE_AMD 1
/**************************
* cl_amd_offline_devices *
**************************/
#define CL_CONTEXT_OFFLINE_DEVICES_AMD 0x403F
/********************************
* cl_amd_bus_addressable_memory *
********************************/
/* cl_mem flag - bitfield */
#define CL_MEM_BUS_ADDRESSABLE_AMD (1<<30)
#define CL_MEM_EXTERNAL_PHYSICAL_AMD (1<<31)
#define CL_COMMAND_WAIT_SIGNAL_AMD 0x4080
#define CL_COMMAND_WRITE_SIGNAL_AMD 0x4081
#define CL_COMMAND_MAKE_BUFFERS_RESIDENT_AMD 0x4082
typedef struct _cl_bus_address_amd
{
cl_ulong surface_bus_address;
cl_ulong marker_bus_address;
} cl_bus_address_amd;
typedef CL_API_ENTRY cl_int
(CL_API_CALL * clEnqueueWaitSignalAMD_fn)( cl_command_queue /*command_queue*/,
cl_mem /*mem_object*/,
cl_uint /*value*/,
cl_uint /*num_events*/,
const cl_event * /*event_wait_list*/,
cl_event * /*event*/) CL_EXT_SUFFIX__VERSION_1_2;
typedef CL_API_ENTRY cl_int
(CL_API_CALL * clEnqueueWriteSignalAMD_fn)( cl_command_queue /*command_queue*/,
cl_mem /*mem_object*/,
cl_uint /*value*/,
cl_ulong /*offset*/,
cl_uint /*num_events*/,
const cl_event * /*event_list*/,
cl_event * /*event*/) CL_EXT_SUFFIX__VERSION_1_2;
typedef CL_API_ENTRY cl_int
(CL_API_CALL * clEnqueueMakeBuffersResidentAMD_fn)( cl_command_queue /*command_queue*/,
cl_uint /*num_mem_objs*/,
cl_mem * /*mem_objects*/,
cl_bool /*blocking_make_resident*/,
cl_bus_address_amd * /*bus_addresses*/,
cl_uint /*num_events*/,
const cl_event * /*event_list*/,
cl_event * /*event*/) CL_EXT_SUFFIX__VERSION_1_2;
/**********************
* cl_amd_liquid_flash *
***********************/
#define cl_amd_liquid_flash 1
#define CL_COMMAND_READ_SSG_FILE_AMD 0x4083
#define CL_COMMAND_WRITE_SSG_FILE_AMD 0x4087
#define CL_INVALID_FILE_OBJECT_AMD 0x4084
typedef struct _cl_file_amd * cl_file_amd;
typedef cl_uint cl_file_flags_amd;
#define CL_FILE_READ_ONLY_AMD (1 << 0)
#define CL_FILE_WRITE_ONLY_AMD (1 << 1)
#define CL_FILE_READ_WRITE_AMD (1 << 2)
typedef cl_uint cl_file_info_amd;
#define CL_FILE_BLOCK_SIZE_AMD 0x4085
#define CL_FILE_SIZE_AMD 0x4086
typedef CL_API_ENTRY cl_file_amd
(CL_API_CALL * clCreateSsgFileObjectAMD_fn)(cl_context /*context*/,
cl_file_flags_amd /*flags*/,
const wchar_t * /*file_name*/,
cl_int * /*errcode_ret*/) CL_EXT_SUFFIX__VERSION_1_2;
typedef CL_API_ENTRY cl_int
(CL_API_CALL * clGetSsgFileObjectInfoAMD_fn)(cl_file_amd /* file */,
cl_file_info_amd /* param_name */,
size_t /* param_value_size */,
void * /* param_value */,
size_t * /* param_value_size_ret */) CL_EXT_SUFFIX__VERSION_1_2;
typedef CL_API_ENTRY cl_int
(CL_API_CALL * clRetainSsgFileObjectAMD_fn)( cl_file_amd /*file*/) CL_EXT_SUFFIX__VERSION_1_2;
typedef CL_API_ENTRY cl_int
(CL_API_CALL * clReleaseSsgFileObjectAMD_fn)( cl_file_amd /*file*/) CL_EXT_SUFFIX__VERSION_1_2;
typedef CL_API_ENTRY cl_int
(CL_API_CALL * clEnqueueReadSsgFileAMD_fn)(cl_command_queue /*command_queue*/,
cl_mem /*buffer*/,
cl_bool /*blocking_write*/,
size_t /*buffer_offset*/,
size_t /*cb*/,
cl_file_amd /*file*/,
size_t /*file_offset*/,
cl_uint /*num_events_in_wait_list*/,
const cl_event * /*event_wait_list*/,
cl_event * /*event*/) CL_EXT_SUFFIX__VERSION_1_2;
typedef CL_API_ENTRY cl_int
(CL_API_CALL * clEnqueueWriteSsgFileAMD_fn)(cl_command_queue /*command_queue*/,
cl_mem /*buffer*/,
cl_bool /*blocking_read*/,
size_t /*buffer_offset*/,
size_t /*cb*/,
cl_file_amd /*file*/,
size_t /*file_offset*/,
cl_uint /*num_events_in_wait_list*/,
const cl_event * /*event_wait_list*/,
cl_event * /*event*/) CL_EXT_SUFFIX__VERSION_1_2;
/*************************
* cl_amd_copy_buffer_p2p *
**************************/
#define CL_DEVICE_NUM_P2P_DEVICES_AMD 0x4088
#define CL_DEVICE_P2P_DEVICES_AMD 0x4089
#define cl_amd_copy_buffer_p2p 1
typedef CL_API_ENTRY cl_int
(CL_API_CALL * clEnqueueCopyBufferP2PAMD_fn)(cl_command_queue /*command_queue*/,
cl_mem /*src_buffer*/,
cl_mem /*dst_buffer*/,
size_t /*src_offset*/,
size_t /*dst_offset*/,
size_t /*cb*/,
cl_uint /*num_events_in_wait_list*/,
const cl_event* /*event_wait_list*/,
cl_event* /*event*/) CL_EXT_SUFFIX__VERSION_1_2;
/***********************************
* cl_amd_assembly_program extension *
***********************************/
#define cl_amd_assembly_program 1
typedef CL_API_ENTRY cl_program (CL_API_CALL * clCreateProgramWithAssemblyAMD_fn) (
cl_context /* context */,
cl_uint /* count */,
const char** /* strings */,
const size_t* /* lengths */,
cl_int* /* errcode_ret */) CL_EXT_SUFFIX__VERSION_1_2;
#ifdef CL_VERSION_2_0
/********************************
* cl_amd_planar_yuv *
********************************/
/* cl_mem flag - bitfield */
#define CL_YUV_IMAGE_Y_PLANE_AMD 0x0
#define CL_YUV_IMAGE_UV_PLANE_AMD 0x1
typedef CL_API_ENTRY cl_mem
(CL_API_CALL * clGetPlaneFromImageAMD_fn)(cl_context /*context*/,
cl_mem /*mem*/,
cl_uint /*plane*/,
cl_int * /*errcode_ret*/) CL_EXT_SUFFIX__VERSION_2_0;
#endif
// <amd_internal>
/***************************
* cl_amd_command_intercept *
***************************/
#define CL_CONTEXT_COMMAND_INTERCEPT_CALLBACK_AMD 0x403D
#define CL_QUEUE_COMMAND_INTERCEPT_ENABLE_AMD (1ull << 63)
typedef cl_int (CL_CALLBACK * intercept_callback_fn)(cl_event, cl_int *);
/**************************
* cl_amd_command_queue_info *
**************************/
#define CL_QUEUE_THREAD_HANDLE_AMD 0x403E
/* cl_kernel_exec_info for DVR DOPP texture support */
#define CL_KERNEL_EXEC_INFO_NEW_VCOP_AMD 0x4120
#define CL_KERNEL_EXEC_INFO_PFPA_VCOP_AMD 0x4121
/*************************
* cl_amd_object_metadata *
**************************/
#define cl_amd_object_metadata 1
typedef size_t cl_key_amd;
#define CL_INVALID_OBJECT_AMD 0x403A
#define CL_INVALID_KEY_AMD 0x403B
#define CL_PLATFORM_MAX_KEYS_AMD 0x403C
typedef CL_API_ENTRY cl_key_amd (CL_API_CALL * clCreateKeyAMD_fn)(
cl_platform_id /* platform */,
void (CL_CALLBACK * /* destructor */)( void* /* old_value */),
cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_1;
typedef CL_API_ENTRY cl_int (CL_API_CALL * clObjectGetValueForKeyAMD_fn)(
void * /* object */,
cl_key_amd /* key */,
void ** /* ret_val */) CL_API_SUFFIX__VERSION_1_1;
typedef CL_API_ENTRY cl_int (CL_API_CALL * clObjectSetValueForKeyAMD_fn)(
void * /* object */,
cl_key_amd /* key */,
void * /* value */) CL_API_SUFFIX__VERSION_1_1;
// </amd_internal>
/*********************************
* cl_arm_printf extension
*********************************/
#define CL_PRINTF_CALLBACK_ARM 0x40B0
#define CL_PRINTF_BUFFERSIZE_ARM 0x40B1
#ifdef CL_VERSION_1_1
/***********************************
* cl_ext_device_fission extension *
***********************************/
#define cl_ext_device_fission 1
extern CL_API_ENTRY cl_int CL_API_CALL
clReleaseDeviceEXT( cl_device_id /*device*/ ) CL_EXT_SUFFIX__VERSION_1_1;
typedef CL_API_ENTRY cl_int
(CL_API_CALL *clReleaseDeviceEXT_fn)( cl_device_id /*device*/ ) CL_EXT_SUFFIX__VERSION_1_1;
extern CL_API_ENTRY cl_int CL_API_CALL
clRetainDeviceEXT( cl_device_id /*device*/ ) CL_EXT_SUFFIX__VERSION_1_1;
typedef CL_API_ENTRY cl_int
(CL_API_CALL *clRetainDeviceEXT_fn)( cl_device_id /*device*/ ) CL_EXT_SUFFIX__VERSION_1_1;
typedef cl_ulong cl_device_partition_property_ext;
extern CL_API_ENTRY cl_int CL_API_CALL
clCreateSubDevicesEXT( cl_device_id /*in_device*/,
const cl_device_partition_property_ext * /* properties */,
cl_uint /*num_entries*/,
cl_device_id * /*out_devices*/,
cl_uint * /*num_devices*/ ) CL_EXT_SUFFIX__VERSION_1_1;
typedef CL_API_ENTRY cl_int
( CL_API_CALL * clCreateSubDevicesEXT_fn)( cl_device_id /*in_device*/,
const cl_device_partition_property_ext * /* properties */,
cl_uint /*num_entries*/,
cl_device_id * /*out_devices*/,
cl_uint * /*num_devices*/ ) CL_EXT_SUFFIX__VERSION_1_1;
/* cl_device_partition_property_ext */
#define CL_DEVICE_PARTITION_EQUALLY_EXT 0x4050
#define CL_DEVICE_PARTITION_BY_COUNTS_EXT 0x4051
#define CL_DEVICE_PARTITION_BY_NAMES_EXT 0x4052
#define CL_DEVICE_PARTITION_BY_AFFINITY_DOMAIN_EXT 0x4053
/* clDeviceGetInfo selectors */
#define CL_DEVICE_PARENT_DEVICE_EXT 0x4054
#define CL_DEVICE_PARTITION_TYPES_EXT 0x4055
#define CL_DEVICE_AFFINITY_DOMAINS_EXT 0x4056
#define CL_DEVICE_REFERENCE_COUNT_EXT 0x4057
#define CL_DEVICE_PARTITION_STYLE_EXT 0x4058
/* clGetImageInfo enum */
#define CL_IMAGE_BYTE_PITCH_AMD 0x4059
/* error codes */
#define CL_DEVICE_PARTITION_FAILED_EXT -1057
#define CL_INVALID_PARTITION_COUNT_EXT -1058
#define CL_INVALID_PARTITION_NAME_EXT -1059
/* CL_AFFINITY_DOMAINs */
#define CL_AFFINITY_DOMAIN_L1_CACHE_EXT 0x1
#define CL_AFFINITY_DOMAIN_L2_CACHE_EXT 0x2
#define CL_AFFINITY_DOMAIN_L3_CACHE_EXT 0x3
#define CL_AFFINITY_DOMAIN_L4_CACHE_EXT 0x4
#define CL_AFFINITY_DOMAIN_NUMA_EXT 0x10
#define CL_AFFINITY_DOMAIN_NEXT_FISSIONABLE_EXT 0x100
/* cl_device_partition_property_ext list terminators */
#define CL_PROPERTIES_LIST_END_EXT ((cl_device_partition_property_ext) 0)
#define CL_PARTITION_BY_COUNTS_LIST_END_EXT ((cl_device_partition_property_ext) 0)
#define CL_PARTITION_BY_NAMES_LIST_END_EXT ((cl_device_partition_property_ext) 0 - 1)
/*********************************
* cl_qcom_ext_host_ptr extension
*********************************/
#define CL_MEM_EXT_HOST_PTR_QCOM (1 << 29)
#define CL_DEVICE_EXT_MEM_PADDING_IN_BYTES_QCOM 0x40A0
#define CL_DEVICE_PAGE_SIZE_QCOM 0x40A1
#define CL_IMAGE_ROW_ALIGNMENT_QCOM 0x40A2
#define CL_IMAGE_SLICE_ALIGNMENT_QCOM 0x40A3
#define CL_MEM_HOST_UNCACHED_QCOM 0x40A4
#define CL_MEM_HOST_WRITEBACK_QCOM 0x40A5
#define CL_MEM_HOST_WRITETHROUGH_QCOM 0x40A6
#define CL_MEM_HOST_WRITE_COMBINING_QCOM 0x40A7
typedef cl_uint cl_image_pitch_info_qcom;
extern CL_API_ENTRY cl_int CL_API_CALL
clGetDeviceImageInfoQCOM(cl_device_id device,
size_t image_width,
size_t image_height,
const cl_image_format *image_format,
cl_image_pitch_info_qcom param_name,
size_t param_value_size,
void *param_value,
size_t *param_value_size_ret);
typedef struct _cl_mem_ext_host_ptr
{
/* Type of external memory allocation. */
/* Legal values will be defined in layered extensions. */
cl_uint allocation_type;
/* Host cache policy for this external memory allocation. */
cl_uint host_cache_policy;
} cl_mem_ext_host_ptr;
/*********************************
* cl_qcom_ion_host_ptr extension
*********************************/
#define CL_MEM_ION_HOST_PTR_QCOM 0x40A8
typedef struct _cl_mem_ion_host_ptr
{
/* Type of external memory allocation. */
/* Must be CL_MEM_ION_HOST_PTR_QCOM for ION allocations. */
cl_mem_ext_host_ptr ext_host_ptr;
/* ION file descriptor */
int ion_filedesc;
/* Host pointer to the ION allocated memory */
void* ion_hostptr;
} cl_mem_ion_host_ptr;
#endif /* CL_VERSION_1_1 */
#if defined(CL_VERSION_1_2)
/******************************************
* cl_img_yuv_image extension *
******************************************/
/* Image formats used in clCreateImage */
#define CL_NV21_IMG 0x40D0
#define CL_YV12_IMG 0x40D1
/******************************************
* cl_img_cached_allocations extension *
******************************************/
/* Flag values used by clCreteBuffer */
#define CL_MEM_USE_UNCACHED_CPU_MEMORY_IMG (1 << 26)
#define CL_MEM_USE_CACHED_CPU_MEMORY_IMG (1 << 27)
/******************************************
* cl_img_use_gralloc_ptr extension *
******************************************/
/* Flag values used by clCreteBuffer */
#define CL_MEM_USE_GRALLOC_PTR_IMG (1 << 28)
/* To be used by clGetEventInfo: */
#define CL_COMMAND_ACQUIRE_GRALLOC_OBJECTS_IMG 0x40D2
#define CL_COMMAND_RELEASE_GRALLOC_OBJECTS_IMG 0x40D3
/* Error code from clEnqueueReleaseGrallocObjectsIMG */
#define CL_GRALLOC_RESOURCE_NOT_ACQUIRED_IMG 0x40D4
extern CL_API_ENTRY cl_int CL_API_CALL
clEnqueueAcquireGrallocObjectsIMG(cl_command_queue /* command_queue */,
cl_uint /* num_objects */,
const cl_mem * /* mem_objects */,
cl_uint /* num_events_in_wait_list */,
const cl_event * /* event_wait_list */,
cl_event * /* event */) CL_EXT_SUFFIX__VERSION_1_2;
extern CL_API_ENTRY cl_int CL_API_CALL
clEnqueueReleaseGrallocObjectsIMG(cl_command_queue /* command_queue */,
cl_uint /* num_objects */,
const cl_mem * /* mem_objects */,
cl_uint /* num_events_in_wait_list */,
const cl_event * /* event_wait_list */,
cl_event * /* event */) CL_EXT_SUFFIX__VERSION_1_2;
#endif /* CL_VERSION_1_2 */
#ifdef CL_VERSION_2_0
/*********************************
* cl_khr_subgroups extension
*********************************/
#define cl_khr_subgroups 1
/* cl_kernel_sub_group_info is declared in CL.h. */
/* cl_kernel_sub_group_info */
#define CL_KERNEL_MAX_SUB_GROUP_SIZE_FOR_NDRANGE_KHR 0x2033
#define CL_KERNEL_SUB_GROUP_COUNT_FOR_NDRANGE_KHR 0x2034
extern CL_API_ENTRY cl_int CL_API_CALL
clGetKernelSubGroupInfoKHR(cl_kernel /* in_kernel */,
cl_device_id /*in_device*/,
cl_kernel_sub_group_info /* param_name */,
size_t /*input_value_size*/,
const void * /*input_value*/,
size_t /*param_value_size*/,
void* /*param_value*/,
size_t* /*param_value_size_ret*/ ) CL_EXT_SUFFIX__VERSION_2_0_DEPRECATED;
typedef CL_API_ENTRY cl_int
( CL_API_CALL * clGetKernelSubGroupInfoKHR_fn)(cl_kernel /* in_kernel */,
cl_device_id /*in_device*/,
cl_kernel_sub_group_info /* param_name */,
size_t /*input_value_size*/,
const void * /*input_value*/,
size_t /*param_value_size*/,
void* /*param_value*/,
size_t* /*param_value_size_ret*/ ) CL_EXT_SUFFIX__VERSION_2_0_DEPRECATED;
#endif /* CL_VERSION_2_0 */
#ifdef CL_VERSION_2_1
/*********************************
* cl_khr_priority_hints extension
*********************************/
#define cl_khr_priority_hints 1
typedef cl_uint cl_queue_priority_khr;
/* cl_command_queue_properties */
#define CL_QUEUE_PRIORITY_KHR 0x1096
/* cl_queue_priority_khr */
#define CL_QUEUE_PRIORITY_HIGH_KHR (1<<0)
#define CL_QUEUE_PRIORITY_MED_KHR (1<<1)
#define CL_QUEUE_PRIORITY_LOW_KHR (1<<2)
#endif /* CL_VERSION_2_1 */
#ifdef CL_VERSION_2_1
/*********************************
* cl_khr_throttle_hints extension
*********************************/
#define cl_khr_throttle_hints 1
typedef cl_uint cl_queue_throttle_khr;
/* cl_command_queue_properties */
#define CL_QUEUE_THROTTLE_KHR 0x1097
/* cl_queue_throttle_khr */
#define CL_QUEUE_THROTTLE_HIGH_KHR (1<<0)
#define CL_QUEUE_THROTTLE_MED_KHR (1<<1)
#define CL_QUEUE_THROTTLE_LOW_KHR (1<<2)
#endif /* CL_VERSION_2_1 */
#ifdef CL_VERSION_2_2
/*********************************
* cl_khr_subgroup_named_barrier
*********************************/
#define cl_khr_subgroup_named_barrier 1
/* cl_device_info */
#define CL_DEVICE_MAX_NAMED_BARRIER_COUNT_KHR 0x2035
#endif /* CL_VERSION_2_2 */
/**********************************
* cl_arm_import_memory extension *
**********************************/
#ifdef CL_VERSION_1_0
typedef intptr_t cl_import_properties_arm;
/* Default and valid proporties name for cl_arm_import_memory */
#define CL_IMPORT_TYPE_ARM 0x40B2
/* Host process memory type default value for CL_IMPORT_TYPE_ARM property */
#define CL_IMPORT_TYPE_HOST_ARM 0x40B3
/* DMA BUF memory type value for CL_IMPORT_TYPE_ARM property */
#define CL_IMPORT_TYPE_DMA_BUF_ARM 0x40B4
/* Secure DMA BUF memory type value for CL_IMPORT_TYPE_ARM property */
#define CL_IMPORT_TYPE_SECURE_ARM 0x40B5
/* This extension adds a new function that allows for direct memory import into
* OpenCL via the clImportMemoryARM function.
*
* Memory imported through this interface will be mapped into the device's page
* tables directly, providing zero copy access. It will never fall back to copy
* operations and aliased buffers.
*
* Types of memory supported for import are specified as additional extension
* strings.
*
* This extension produces cl_mem allocations which are compatible with all other
* users of cl_mem in the standard API.
*
* This extension maps pages with the same properties as the normal buffer creation
* function clCreateBuffer.
*/
extern CL_API_ENTRY cl_mem CL_API_CALL
clImportMemoryARM( cl_context context,
cl_mem_flags flags,
const cl_import_properties_arm *properties,
void *memory,
size_t size,
cl_int *errcode_ret) CL_EXT_SUFFIX__VERSION_1_0;
#endif /* CL_VERSION_1_0 */
/******************************************
* cl_arm_shared_virtual_memory extension *
******************************************/
#ifdef CL_VERSION_1_2
/* Used by clGetDeviceInfo */
#define CL_DEVICE_SVM_CAPABILITIES_ARM 0x40B6
/* Used by clGetMemObjectInfo */
#define CL_MEM_USES_SVM_POINTER_ARM 0x40B7
/* Used by clSetKernelExecInfoARM: */
#define CL_KERNEL_EXEC_INFO_SVM_PTRS_ARM 0x40B8
#define CL_KERNEL_EXEC_INFO_SVM_FINE_GRAIN_SYSTEM_ARM 0x40B9
/* To be used by clGetEventInfo: */
#define CL_COMMAND_SVM_FREE_ARM 0x40BA
#define CL_COMMAND_SVM_MEMCPY_ARM 0x40BB
#define CL_COMMAND_SVM_MEMFILL_ARM 0x40BC
#define CL_COMMAND_SVM_MAP_ARM 0x40BD
#define CL_COMMAND_SVM_UNMAP_ARM 0x40BE
/* Flag values returned by clGetDeviceInfo with CL_DEVICE_SVM_CAPABILITIES_ARM as the param_name. */
#define CL_DEVICE_SVM_COARSE_GRAIN_BUFFER_ARM (1 << 0)
#define CL_DEVICE_SVM_FINE_GRAIN_BUFFER_ARM (1 << 1)
#define CL_DEVICE_SVM_FINE_GRAIN_SYSTEM_ARM (1 << 2)
#define CL_DEVICE_SVM_ATOMICS_ARM (1 << 3)
/* Flag values used by clSVMAllocARM: */
#define CL_MEM_SVM_FINE_GRAIN_BUFFER_ARM (1 << 10)
#define CL_MEM_SVM_ATOMICS_ARM (1 << 11)
typedef cl_bitfield cl_svm_mem_flags_arm;
typedef cl_uint cl_kernel_exec_info_arm;
typedef cl_bitfield cl_device_svm_capabilities_arm;
extern CL_API_ENTRY void * CL_API_CALL
clSVMAllocARM(cl_context /* context */,
cl_svm_mem_flags_arm /* flags */,
size_t /* size */,
cl_uint /* alignment */) CL_EXT_SUFFIX__VERSION_1_2;
extern CL_API_ENTRY void CL_API_CALL
clSVMFreeARM(cl_context /* context */,
void * /* svm_pointer */) CL_EXT_SUFFIX__VERSION_1_2;
extern CL_API_ENTRY cl_int CL_API_CALL
clEnqueueSVMFreeARM(cl_command_queue /* command_queue */,
cl_uint /* num_svm_pointers */,
void *[] /* svm_pointers[] */,
void (CL_CALLBACK * /*pfn_free_func*/)(cl_command_queue /* queue */,
cl_uint /* num_svm_pointers */,
void *[] /* svm_pointers[] */,
void * /* user_data */),
void * /* user_data */,
cl_uint /* num_events_in_wait_list */,
const cl_event * /* event_wait_list */,
cl_event * /* event */) CL_EXT_SUFFIX__VERSION_1_2;
extern CL_API_ENTRY cl_int CL_API_CALL
clEnqueueSVMMemcpyARM(cl_command_queue /* command_queue */,
cl_bool /* blocking_copy */,
void * /* dst_ptr */,
const void * /* src_ptr */,
size_t /* size */,
cl_uint /* num_events_in_wait_list */,
const cl_event * /* event_wait_list */,
cl_event * /* event */) CL_EXT_SUFFIX__VERSION_1_2;
extern CL_API_ENTRY cl_int CL_API_CALL
clEnqueueSVMMemFillARM(cl_command_queue /* command_queue */,
void * /* svm_ptr */,
const void * /* pattern */,
size_t /* pattern_size */,
size_t /* size */,
cl_uint /* num_events_in_wait_list */,
const cl_event * /* event_wait_list */,
cl_event * /* event */) CL_EXT_SUFFIX__VERSION_1_2;
extern CL_API_ENTRY cl_int CL_API_CALL
clEnqueueSVMMapARM(cl_command_queue /* command_queue */,
cl_bool /* blocking_map */,
cl_map_flags /* flags */,
void * /* svm_ptr */,
size_t /* size */,
cl_uint /* num_events_in_wait_list */,
const cl_event * /* event_wait_list */,
cl_event * /* event */) CL_EXT_SUFFIX__VERSION_1_2;
extern CL_API_ENTRY cl_int CL_API_CALL
clEnqueueSVMUnmapARM(cl_command_queue /* command_queue */,
void * /* svm_ptr */,
cl_uint /* num_events_in_wait_list */,
const cl_event * /* event_wait_list */,
cl_event * /* event */) CL_EXT_SUFFIX__VERSION_1_2;
extern CL_API_ENTRY cl_int CL_API_CALL
clSetKernelArgSVMPointerARM(cl_kernel /* kernel */,
cl_uint /* arg_index */,
const void * /* arg_value */) CL_EXT_SUFFIX__VERSION_1_2;
extern CL_API_ENTRY cl_int CL_API_CALL
clSetKernelExecInfoARM(cl_kernel /* kernel */,
cl_kernel_exec_info_arm /* param_name */,
size_t /* param_value_size */,
const void * /* param_value */) CL_EXT_SUFFIX__VERSION_1_2;
#endif /* CL_VERSION_1_2 */
#ifdef __cplusplus
}
#endif
#endif /* __CL_EXT_H */
projects/hip/amdocl/CL/cl_gl.h
+167
View File
@@ -0,0 +1,167 @@
/**********************************************************************************
* Copyright (c) 2008-2015 The Khronos Group Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and/or associated documentation files (the
* "Materials"), to deal in the Materials without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Materials, and to
* permit persons to whom the Materials are furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Materials.
*
* MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
* KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
* SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
* https://www.khronos.org/registry/
*
* THE MATERIALS ARE 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 AUTHORS 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
* MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
**********************************************************************************/
#ifndef __OPENCL_CL_GL_H
#define __OPENCL_CL_GL_H
#ifdef __APPLE__
#include <OpenCL/cl.h>
#else
#include <CL/cl.h>
#endif
#ifdef __cplusplus
extern "C" {
#endif
typedef cl_uint cl_gl_object_type;
typedef cl_uint cl_gl_texture_info;
typedef cl_uint cl_gl_platform_info;
typedef struct __GLsync *cl_GLsync;
/* cl_gl_object_type = 0x2000 - 0x200F enum values are currently taken */
#define CL_GL_OBJECT_BUFFER 0x2000
#define CL_GL_OBJECT_TEXTURE2D 0x2001
#define CL_GL_OBJECT_TEXTURE3D 0x2002
#define CL_GL_OBJECT_RENDERBUFFER 0x2003
#define CL_GL_OBJECT_TEXTURE2D_ARRAY 0x200E
#define CL_GL_OBJECT_TEXTURE1D 0x200F
#define CL_GL_OBJECT_TEXTURE1D_ARRAY 0x2010
#define CL_GL_OBJECT_TEXTURE_BUFFER 0x2011
/* cl_gl_texture_info */
#define CL_GL_TEXTURE_TARGET 0x2004
#define CL_GL_MIPMAP_LEVEL 0x2005
#define CL_GL_NUM_SAMPLES 0x2012
extern CL_API_ENTRY cl_mem CL_API_CALL
clCreateFromGLBuffer(cl_context /* context */,
cl_mem_flags /* flags */,
cl_GLuint /* bufobj */,
int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_mem CL_API_CALL
clCreateFromGLTexture(cl_context /* context */,
cl_mem_flags /* flags */,
cl_GLenum /* target */,
cl_GLint /* miplevel */,
cl_GLuint /* texture */,
cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_2;
extern CL_API_ENTRY cl_mem CL_API_CALL
clCreateFromGLRenderbuffer(cl_context /* context */,
cl_mem_flags /* flags */,
cl_GLuint /* renderbuffer */,
cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clGetGLObjectInfo(cl_mem /* memobj */,
cl_gl_object_type * /* gl_object_type */,
cl_GLuint * /* gl_object_name */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clGetGLTextureInfo(cl_mem /* memobj */,
cl_gl_texture_info /* param_name */,
size_t /* param_value_size */,
void * /* param_value */,
size_t * /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clEnqueueAcquireGLObjects(cl_command_queue /* command_queue */,
cl_uint /* num_objects */,
const cl_mem * /* mem_objects */,
cl_uint /* num_events_in_wait_list */,
const cl_event * /* event_wait_list */,
cl_event * /* event */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL
clEnqueueReleaseGLObjects(cl_command_queue /* command_queue */,
cl_uint /* num_objects */,
const cl_mem * /* mem_objects */,
cl_uint /* num_events_in_wait_list */,
const cl_event * /* event_wait_list */,
cl_event * /* event */) CL_API_SUFFIX__VERSION_1_0;
/* Deprecated OpenCL 1.1 APIs */
extern CL_API_ENTRY CL_EXT_PREFIX__VERSION_1_1_DEPRECATED cl_mem CL_API_CALL
clCreateFromGLTexture2D(cl_context /* context */,
cl_mem_flags /* flags */,
cl_GLenum /* target */,
cl_GLint /* miplevel */,
cl_GLuint /* texture */,
cl_int * /* errcode_ret */) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED;
extern CL_API_ENTRY CL_EXT_PREFIX__VERSION_1_1_DEPRECATED cl_mem CL_API_CALL
clCreateFromGLTexture3D(cl_context /* context */,
cl_mem_flags /* flags */,
cl_GLenum /* target */,
cl_GLint /* miplevel */,
cl_GLuint /* texture */,
cl_int * /* errcode_ret */) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED;
/* cl_khr_gl_sharing extension */
#define cl_khr_gl_sharing 1
typedef cl_uint cl_gl_context_info;
/* Additional Error Codes */
#define CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR -1000
/* cl_gl_context_info */
#define CL_CURRENT_DEVICE_FOR_GL_CONTEXT_KHR 0x2006
#define CL_DEVICES_FOR_GL_CONTEXT_KHR 0x2007
/* Additional cl_context_properties */
#define CL_GL_CONTEXT_KHR 0x2008
#define CL_EGL_DISPLAY_KHR 0x2009
#define CL_GLX_DISPLAY_KHR 0x200A
#define CL_WGL_HDC_KHR 0x200B
#define CL_CGL_SHAREGROUP_KHR 0x200C
extern CL_API_ENTRY cl_int CL_API_CALL
clGetGLContextInfoKHR(const cl_context_properties * /* properties */,
cl_gl_context_info /* param_name */,
size_t /* param_value_size */,
void * /* param_value */,
size_t * /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
typedef CL_API_ENTRY cl_int (CL_API_CALL *clGetGLContextInfoKHR_fn)(
const cl_context_properties * properties,
cl_gl_context_info param_name,
size_t param_value_size,
void * param_value,
size_t * param_value_size_ret);
#ifdef __cplusplus
}
#endif
#endif /* __OPENCL_CL_GL_H */
projects/hip/amdocl/CL/cl_gl_ext.h
+74
View File
@@ -0,0 +1,74 @@
/**********************************************************************************
* Copyright (c) 2008-2015 The Khronos Group Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and/or associated documentation files (the
* "Materials"), to deal in the Materials without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Materials, and to
* permit persons to whom the Materials are furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Materials.
*
* MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
* KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
* SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
* https://www.khronos.org/registry/
*
* THE MATERIALS ARE 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 AUTHORS 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
* MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
**********************************************************************************/
/* $Revision: 11708 $ on $Date: 2010-06-13 23:36:24 -0700 (Sun, 13 Jun 2010) $ */
/* cl_gl_ext.h contains vendor (non-KHR) OpenCL extensions which have */
/* OpenGL dependencies. */
#ifndef __OPENCL_CL_GL_EXT_H
#define __OPENCL_CL_GL_EXT_H
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __APPLE__
#include <OpenCL/cl_gl.h>
#else
#include <CL/cl_gl.h>
#endif
/*
* For each extension, follow this template
* cl_VEN_extname extension */
/* #define cl_VEN_extname 1
* ... define new types, if any
* ... define new tokens, if any
* ... define new APIs, if any
*
* If you need GLtypes here, mirror them with a cl_GLtype, rather than including a GL header
* This allows us to avoid having to decide whether to include GL headers or GLES here.
*/
/*
* cl_khr_gl_event extension
* See section 9.9 in the OpenCL 1.1 spec for more information
*/
#define CL_COMMAND_GL_FENCE_SYNC_OBJECT_KHR 0x200D
extern CL_API_ENTRY cl_event CL_API_CALL
clCreateEventFromGLsyncKHR(cl_context /* context */,
cl_GLsync /* cl_GLsync */,
cl_int * /* errcode_ret */) CL_EXT_SUFFIX__VERSION_1_1;
#ifdef __cplusplus
}
#endif
#endif /* __OPENCL_CL_GL_EXT_H */
projects/hip/amdocl/CL/cl_platform.h
+1458
View File
File diff suppressed because it is too large Load Diff
projects/hip/amdocl/CL/opencl.h
+59
View File
@@ -0,0 +1,59 @@
/*******************************************************************************
* Copyright (c) 2008-2015 The Khronos Group Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and/or associated documentation files (the
* "Materials"), to deal in the Materials without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Materials, and to
* permit persons to whom the Materials are furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Materials.
*
* MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
* KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
* SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
* https://www.khronos.org/registry/
*
* THE MATERIALS ARE 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 AUTHORS 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
* MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
******************************************************************************/
/* $Revision: 11708 $ on $Date: 2010-06-13 23:36:24 -0700 (Sun, 13 Jun 2010) $ */
#ifndef __OPENCL_H
#define __OPENCL_H
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __APPLE__
#include <OpenCL/cl.h>
#include <OpenCL/cl_gl.h>
#include <OpenCL/cl_gl_ext.h>
#include <OpenCL/cl_ext.h>
#else
#include <CL/cl.h>
#include <CL/cl_gl.h>
#include <CL/cl_gl_ext.h>
#include <CL/cl_ext.h>
#endif
#ifdef __cplusplus
}
#endif
#endif /* __OPENCL_H */
projects/hip/amdocl/EGL/egl.h
+329
View File
@@ -0,0 +1,329 @@
/* -*- mode: c; tab-width: 8; -*- */
/* vi: set sw=4 ts=8: */
/* Reference version of egl.h for EGL 1.4.
* $Revision: 9356 $ on $Date: 2009-10-21 02:52:25 -0700 (Wed, 21 Oct 2009) $
*/
/*
** Copyright (c) 2007-2009 The Khronos Group Inc.
**
** Permission is hereby granted, free of charge, to any person obtaining a
** copy of this software and/or associated documentation files (the
** "Materials"), to deal in the Materials without restriction, including
** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Materials, and to
** permit persons to whom the Materials are furnished to do so, subject to
** the following conditions:
**
** The above copyright notice and this permission notice shall be included
** in all copies or substantial portions of the Materials.
**
** THE MATERIALS ARE 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 AUTHORS 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
** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
*/
#ifndef __egl_h_
#define __egl_h_
/* All platform-dependent types and macro boilerplate (such as EGLAPI
* and EGLAPIENTRY) should go in eglplatform.h.
*/
#include <EGL/eglplatform.h>
#ifdef __cplusplus
extern "C" {
#endif
/* EGL Types */
/* EGLint is defined in eglplatform.h */
typedef unsigned int EGLBoolean;
typedef unsigned int EGLenum;
typedef void *EGLConfig;
typedef void *EGLContext;
typedef void *EGLDisplay;
typedef void *EGLSurface;
typedef void *EGLClientBuffer;
/* EGL Versioning */
#define EGL_VERSION_1_0 1
#define EGL_VERSION_1_1 1
#define EGL_VERSION_1_2 1
#define EGL_VERSION_1_3 1
#define EGL_VERSION_1_4 1
/* EGL Enumerants. Bitmasks and other exceptional cases aside, most
* enums are assigned unique values starting at 0x3000.
*/
/* EGL aliases */
#define EGL_FALSE 0
#define EGL_TRUE 1
/* Out-of-band handle values */
#define EGL_DEFAULT_DISPLAY ((EGLNativeDisplayType)0)
#define EGL_NO_CONTEXT ((EGLContext)0)
#define EGL_NO_DISPLAY ((EGLDisplay)0)
#define EGL_NO_SURFACE ((EGLSurface)0)
/* Out-of-band attribute value */
#define EGL_DONT_CARE ((EGLint)-1)
/* Errors / GetError return values */
#define EGL_SUCCESS 0x3000
#define EGL_NOT_INITIALIZED 0x3001
#define EGL_BAD_ACCESS 0x3002
#define EGL_BAD_ALLOC 0x3003
#define EGL_BAD_ATTRIBUTE 0x3004
#define EGL_BAD_CONFIG 0x3005
#define EGL_BAD_CONTEXT 0x3006
#define EGL_BAD_CURRENT_SURFACE 0x3007
#define EGL_BAD_DISPLAY 0x3008
#define EGL_BAD_MATCH 0x3009
#define EGL_BAD_NATIVE_PIXMAP 0x300A
#define EGL_BAD_NATIVE_WINDOW 0x300B
#define EGL_BAD_PARAMETER 0x300C
#define EGL_BAD_SURFACE 0x300D
#define EGL_CONTEXT_LOST 0x300E /* EGL 1.1 - IMG_power_management */
/* Reserved 0x300F-0x301F for additional errors */
/* Config attributes */
#define EGL_BUFFER_SIZE 0x3020
#define EGL_ALPHA_SIZE 0x3021
#define EGL_BLUE_SIZE 0x3022
#define EGL_GREEN_SIZE 0x3023
#define EGL_RED_SIZE 0x3024
#define EGL_DEPTH_SIZE 0x3025
#define EGL_STENCIL_SIZE 0x3026
#define EGL_CONFIG_CAVEAT 0x3027
#define EGL_CONFIG_ID 0x3028
#define EGL_LEVEL 0x3029
#define EGL_MAX_PBUFFER_HEIGHT 0x302A
#define EGL_MAX_PBUFFER_PIXELS 0x302B
#define EGL_MAX_PBUFFER_WIDTH 0x302C
#define EGL_NATIVE_RENDERABLE 0x302D
#define EGL_NATIVE_VISUAL_ID 0x302E
#define EGL_NATIVE_VISUAL_TYPE 0x302F
#define EGL_SAMPLES 0x3031
#define EGL_SAMPLE_BUFFERS 0x3032
#define EGL_SURFACE_TYPE 0x3033
#define EGL_TRANSPARENT_TYPE 0x3034
#define EGL_TRANSPARENT_BLUE_VALUE 0x3035
#define EGL_TRANSPARENT_GREEN_VALUE 0x3036
#define EGL_TRANSPARENT_RED_VALUE 0x3037
#define EGL_NONE 0x3038 /* Attrib list terminator */
#define EGL_BIND_TO_TEXTURE_RGB 0x3039
#define EGL_BIND_TO_TEXTURE_RGBA 0x303A
#define EGL_MIN_SWAP_INTERVAL 0x303B
#define EGL_MAX_SWAP_INTERVAL 0x303C
#define EGL_LUMINANCE_SIZE 0x303D
#define EGL_ALPHA_MASK_SIZE 0x303E
#define EGL_COLOR_BUFFER_TYPE 0x303F
#define EGL_RENDERABLE_TYPE 0x3040
#define EGL_MATCH_NATIVE_PIXMAP 0x3041 /* Pseudo-attribute (not queryable) */
#define EGL_CONFORMANT 0x3042
/* Reserved 0x3041-0x304F for additional config attributes */
/* Config attribute values */
#define EGL_SLOW_CONFIG 0x3050 /* EGL_CONFIG_CAVEAT value */
#define EGL_NON_CONFORMANT_CONFIG 0x3051 /* EGL_CONFIG_CAVEAT value */
#define EGL_TRANSPARENT_RGB 0x3052 /* EGL_TRANSPARENT_TYPE value */
#define EGL_RGB_BUFFER 0x308E /* EGL_COLOR_BUFFER_TYPE value */
#define EGL_LUMINANCE_BUFFER 0x308F /* EGL_COLOR_BUFFER_TYPE value */
/* More config attribute values, for EGL_TEXTURE_FORMAT */
#define EGL_NO_TEXTURE 0x305C
#define EGL_TEXTURE_RGB 0x305D
#define EGL_TEXTURE_RGBA 0x305E
#define EGL_TEXTURE_2D 0x305F
/* Config attribute mask bits */
#define EGL_PBUFFER_BIT 0x0001 /* EGL_SURFACE_TYPE mask bits */
#define EGL_PIXMAP_BIT 0x0002 /* EGL_SURFACE_TYPE mask bits */
#define EGL_WINDOW_BIT 0x0004 /* EGL_SURFACE_TYPE mask bits */
#define EGL_VG_COLORSPACE_LINEAR_BIT 0x0020 /* EGL_SURFACE_TYPE mask bits */
#define EGL_VG_ALPHA_FORMAT_PRE_BIT 0x0040 /* EGL_SURFACE_TYPE mask bits */
#define EGL_MULTISAMPLE_RESOLVE_BOX_BIT 0x0200 /* EGL_SURFACE_TYPE mask bits */
#define EGL_SWAP_BEHAVIOR_PRESERVED_BIT 0x0400 /* EGL_SURFACE_TYPE mask bits */
#define EGL_OPENGL_ES_BIT 0x0001 /* EGL_RENDERABLE_TYPE mask bits */
#define EGL_OPENVG_BIT 0x0002 /* EGL_RENDERABLE_TYPE mask bits */
#define EGL_OPENGL_ES2_BIT 0x0004 /* EGL_RENDERABLE_TYPE mask bits */
#define EGL_OPENGL_BIT 0x0008 /* EGL_RENDERABLE_TYPE mask bits */
/* QueryString targets */
#define EGL_VENDOR 0x3053
#define EGL_VERSION 0x3054
#define EGL_EXTENSIONS 0x3055
#define EGL_CLIENT_APIS 0x308D
/* QuerySurface / SurfaceAttrib / CreatePbufferSurface targets */
#define EGL_HEIGHT 0x3056
#define EGL_WIDTH 0x3057
#define EGL_LARGEST_PBUFFER 0x3058
#define EGL_TEXTURE_FORMAT 0x3080
#define EGL_TEXTURE_TARGET 0x3081
#define EGL_MIPMAP_TEXTURE 0x3082
#define EGL_MIPMAP_LEVEL 0x3083
#define EGL_RENDER_BUFFER 0x3086
#define EGL_VG_COLORSPACE 0x3087
#define EGL_VG_ALPHA_FORMAT 0x3088
#define EGL_HORIZONTAL_RESOLUTION 0x3090
#define EGL_VERTICAL_RESOLUTION 0x3091
#define EGL_PIXEL_ASPECT_RATIO 0x3092
#define EGL_SWAP_BEHAVIOR 0x3093
#define EGL_MULTISAMPLE_RESOLVE 0x3099
/* EGL_RENDER_BUFFER values / BindTexImage / ReleaseTexImage buffer targets */
#define EGL_BACK_BUFFER 0x3084
#define EGL_SINGLE_BUFFER 0x3085
/* OpenVG color spaces */
#define EGL_VG_COLORSPACE_sRGB 0x3089 /* EGL_VG_COLORSPACE value */
#define EGL_VG_COLORSPACE_LINEAR 0x308A /* EGL_VG_COLORSPACE value */
/* OpenVG alpha formats */
#define EGL_VG_ALPHA_FORMAT_NONPRE 0x308B /* EGL_ALPHA_FORMAT value */
#define EGL_VG_ALPHA_FORMAT_PRE 0x308C /* EGL_ALPHA_FORMAT value */
/* Constant scale factor by which fractional display resolutions &
* aspect ratio are scaled when queried as integer values.
*/
#define EGL_DISPLAY_SCALING 10000
/* Unknown display resolution/aspect ratio */
#define EGL_UNKNOWN ((EGLint)-1)
/* Back buffer swap behaviors */
#define EGL_BUFFER_PRESERVED 0x3094 /* EGL_SWAP_BEHAVIOR value */
#define EGL_BUFFER_DESTROYED 0x3095 /* EGL_SWAP_BEHAVIOR value */
/* CreatePbufferFromClientBuffer buffer types */
#define EGL_OPENVG_IMAGE 0x3096
/* QueryContext targets */
#define EGL_CONTEXT_CLIENT_TYPE 0x3097
/* CreateContext attributes */
#define EGL_CONTEXT_CLIENT_VERSION 0x3098
/* Multisample resolution behaviors */
#define EGL_MULTISAMPLE_RESOLVE_DEFAULT 0x309A /* EGL_MULTISAMPLE_RESOLVE value */
#define EGL_MULTISAMPLE_RESOLVE_BOX 0x309B /* EGL_MULTISAMPLE_RESOLVE value */
/* BindAPI/QueryAPI targets */
#define EGL_OPENGL_ES_API 0x30A0
#define EGL_OPENVG_API 0x30A1
#define EGL_OPENGL_API 0x30A2
/* GetCurrentSurface targets */
#define EGL_DRAW 0x3059
#define EGL_READ 0x305A
/* WaitNative engines */
#define EGL_CORE_NATIVE_ENGINE 0x305B
/* EGL 1.2 tokens renamed for consistency in EGL 1.3 */
#define EGL_COLORSPACE EGL_VG_COLORSPACE
#define EGL_ALPHA_FORMAT EGL_VG_ALPHA_FORMAT
#define EGL_COLORSPACE_sRGB EGL_VG_COLORSPACE_sRGB
#define EGL_COLORSPACE_LINEAR EGL_VG_COLORSPACE_LINEAR
#define EGL_ALPHA_FORMAT_NONPRE EGL_VG_ALPHA_FORMAT_NONPRE
#define EGL_ALPHA_FORMAT_PRE EGL_VG_ALPHA_FORMAT_PRE
/* EGL extensions must request enum blocks from the Khronos
* API Registrar, who maintains the enumerant registry. Submit
* a bug in Khronos Bugzilla against task "Registry".
*/
/* EGL Functions */
EGLAPI EGLint EGLAPIENTRY eglGetError(void);
EGLAPI EGLDisplay EGLAPIENTRY eglGetDisplay(EGLNativeDisplayType display_id);
EGLAPI EGLBoolean EGLAPIENTRY eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor);
EGLAPI EGLBoolean EGLAPIENTRY eglTerminate(EGLDisplay dpy);
EGLAPI const char * EGLAPIENTRY eglQueryString(EGLDisplay dpy, EGLint name);
EGLAPI EGLBoolean EGLAPIENTRY eglGetConfigs(EGLDisplay dpy, EGLConfig *configs,
EGLint config_size, EGLint *num_config);
EGLAPI EGLBoolean EGLAPIENTRY eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list,
EGLConfig *configs, EGLint config_size,
EGLint *num_config);
EGLAPI EGLBoolean EGLAPIENTRY eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config,
EGLint attribute, EGLint *value);
EGLAPI EGLSurface EGLAPIENTRY eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config,
EGLNativeWindowType win,
const EGLint *attrib_list);
EGLAPI EGLSurface EGLAPIENTRY eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config,
const EGLint *attrib_list);
EGLAPI EGLSurface EGLAPIENTRY eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config,
EGLNativePixmapType pixmap,
const EGLint *attrib_list);
EGLAPI EGLBoolean EGLAPIENTRY eglDestroySurface(EGLDisplay dpy, EGLSurface surface);
EGLAPI EGLBoolean EGLAPIENTRY eglQuerySurface(EGLDisplay dpy, EGLSurface surface,
EGLint attribute, EGLint *value);
EGLAPI EGLBoolean EGLAPIENTRY eglBindAPI(EGLenum api);
EGLAPI EGLenum EGLAPIENTRY eglQueryAPI(void);
EGLAPI EGLBoolean EGLAPIENTRY eglWaitClient(void);
EGLAPI EGLBoolean EGLAPIENTRY eglReleaseThread(void);
EGLAPI EGLSurface EGLAPIENTRY eglCreatePbufferFromClientBuffer(
EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer,
EGLConfig config, const EGLint *attrib_list);
EGLAPI EGLBoolean EGLAPIENTRY eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface,
EGLint attribute, EGLint value);
EGLAPI EGLBoolean EGLAPIENTRY eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer);
EGLAPI EGLBoolean EGLAPIENTRY eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer);
EGLAPI EGLBoolean EGLAPIENTRY eglSwapInterval(EGLDisplay dpy, EGLint interval);
EGLAPI EGLContext EGLAPIENTRY eglCreateContext(EGLDisplay dpy, EGLConfig config,
EGLContext share_context,
const EGLint *attrib_list);
EGLAPI EGLBoolean EGLAPIENTRY eglDestroyContext(EGLDisplay dpy, EGLContext ctx);
EGLAPI EGLBoolean EGLAPIENTRY eglMakeCurrent(EGLDisplay dpy, EGLSurface draw,
EGLSurface read, EGLContext ctx);
EGLAPI EGLContext EGLAPIENTRY eglGetCurrentContext(void);
EGLAPI EGLSurface EGLAPIENTRY eglGetCurrentSurface(EGLint readdraw);
EGLAPI EGLDisplay EGLAPIENTRY eglGetCurrentDisplay(void);
EGLAPI EGLBoolean EGLAPIENTRY eglQueryContext(EGLDisplay dpy, EGLContext ctx,
EGLint attribute, EGLint *value);
EGLAPI EGLBoolean EGLAPIENTRY eglWaitGL(void);
EGLAPI EGLBoolean EGLAPIENTRY eglWaitNative(EGLint engine);
EGLAPI EGLBoolean EGLAPIENTRY eglSwapBuffers(EGLDisplay dpy, EGLSurface surface);
EGLAPI EGLBoolean EGLAPIENTRY eglCopyBuffers(EGLDisplay dpy, EGLSurface surface,
EGLNativePixmapType target);
/* This is a generic function pointer type, whose name indicates it must
* be cast to the proper type *and calling convention* before use.
*/
typedef void (*__eglMustCastToProperFunctionPointerType)(void);
/* Now, define eglGetProcAddress using the generic function ptr. type */
EGLAPI __eglMustCastToProperFunctionPointerType EGLAPIENTRY
eglGetProcAddress(const char *procname);
#ifdef __cplusplus
}
#endif
#endif /* __egl_h_ */
projects/hip/amdocl/EGL/eglext.h
+645
View File
@@ -0,0 +1,645 @@
#ifndef __eglext_h_
#define __eglext_h_ 1
#ifdef __cplusplus
extern "C" {
#endif
/*
** Copyright (c) 2013 The Khronos Group Inc.
**
** Permission is hereby granted, free of charge, to any person obtaining a
** copy of this software and/or associated documentation files (the
** "Materials"), to deal in the Materials without restriction, including
** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Materials, and to
** permit persons to whom the Materials are furnished to do so, subject to
** the following conditions:
**
** The above copyright notice and this permission notice shall be included
** in all copies or substantial portions of the Materials.
**
** THE MATERIALS ARE 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 AUTHORS 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
** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
*/
/*
** This header is generated from the Khronos OpenGL / OpenGL ES XML
** API Registry. The current version of the Registry, generator scripts
** used to make the header, and the header can be found at
** http://www.opengl.org/registry/
**
** Khronos $Revision: 24350 $ on $Date: 2013-12-04 12:46:23 -0800 (Wed, 04 Dec 2013) $
*/
#include <EGL/eglplatform.h>
#define EGL_EGLEXT_VERSION 20131204
/* Generated C header for:
* API: egl
* Versions considered: .*
* Versions emitted: _nomatch_^
* Default extensions included: egl
* Additional extensions included: _nomatch_^
* Extensions removed: _nomatch_^
*/
#ifndef EGL_KHR_cl_event
#define EGL_KHR_cl_event 1
#define EGL_CL_EVENT_HANDLE_KHR 0x309C
#define EGL_SYNC_CL_EVENT_KHR 0x30FE
#define EGL_SYNC_CL_EVENT_COMPLETE_KHR 0x30FF
#endif /* EGL_KHR_cl_event */
#ifndef EGL_KHR_cl_event2
#define EGL_KHR_cl_event2 1
typedef void *EGLSyncKHR;
typedef intptr_t EGLAttribKHR;
typedef EGLSyncKHR (EGLAPIENTRYP PFNEGLCREATESYNC64KHRPROC) (EGLDisplay dpy, EGLenum type, const EGLAttribKHR *attrib_list);
#ifdef EGL_EGLEXT_PROTOTYPES
EGLAPI EGLSyncKHR EGLAPIENTRY eglCreateSync64KHR (EGLDisplay dpy, EGLenum type, const EGLAttribKHR *attrib_list);
#endif
#endif /* EGL_KHR_cl_event2 */
#ifndef EGL_KHR_client_get_all_proc_addresses
#define EGL_KHR_client_get_all_proc_addresses 1
#endif /* EGL_KHR_client_get_all_proc_addresses */
#ifndef EGL_KHR_config_attribs
#define EGL_KHR_config_attribs 1
#define EGL_CONFORMANT_KHR 0x3042
#define EGL_VG_COLORSPACE_LINEAR_BIT_KHR 0x0020
#define EGL_VG_ALPHA_FORMAT_PRE_BIT_KHR 0x0040
#endif /* EGL_KHR_config_attribs */
#ifndef EGL_KHR_create_context
#define EGL_KHR_create_context 1
#define EGL_CONTEXT_MAJOR_VERSION_KHR 0x3098
#define EGL_CONTEXT_MINOR_VERSION_KHR 0x30FB
#define EGL_CONTEXT_FLAGS_KHR 0x30FC
#define EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR 0x30FD
#define EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR 0x31BD
#define EGL_NO_RESET_NOTIFICATION_KHR 0x31BE
#define EGL_LOSE_CONTEXT_ON_RESET_KHR 0x31BF
#define EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR 0x00000001
#define EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR 0x00000002
#define EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR 0x00000004
#define EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR 0x00000001
#define EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR 0x00000002
#define EGL_OPENGL_ES3_BIT_KHR 0x00000040
#endif /* EGL_KHR_create_context */
#ifndef EGL_KHR_fence_sync
#define EGL_KHR_fence_sync 1
#ifdef KHRONOS_SUPPORT_INT64
#define EGL_SYNC_PRIOR_COMMANDS_COMPLETE_KHR 0x30F0
#define EGL_SYNC_CONDITION_KHR 0x30F8
#define EGL_SYNC_FENCE_KHR 0x30F9
#endif /* KHRONOS_SUPPORT_INT64 */
#endif /* EGL_KHR_fence_sync */
#ifndef EGL_KHR_get_all_proc_addresses
#define EGL_KHR_get_all_proc_addresses 1
#endif /* EGL_KHR_get_all_proc_addresses */
#ifndef EGL_KHR_gl_renderbuffer_image
#define EGL_KHR_gl_renderbuffer_image 1
#define EGL_GL_RENDERBUFFER_KHR 0x30B9
#endif /* EGL_KHR_gl_renderbuffer_image */
#ifndef EGL_KHR_gl_texture_2D_image
#define EGL_KHR_gl_texture_2D_image 1
#define EGL_GL_TEXTURE_2D_KHR 0x30B1
#define EGL_GL_TEXTURE_LEVEL_KHR 0x30BC
#endif /* EGL_KHR_gl_texture_2D_image */
#ifndef EGL_KHR_gl_texture_3D_image
#define EGL_KHR_gl_texture_3D_image 1
#define EGL_GL_TEXTURE_3D_KHR 0x30B2
#define EGL_GL_TEXTURE_ZOFFSET_KHR 0x30BD
#endif /* EGL_KHR_gl_texture_3D_image */
#ifndef EGL_KHR_gl_texture_cubemap_image
#define EGL_KHR_gl_texture_cubemap_image 1
#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR 0x30B3
#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X_KHR 0x30B4
#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y_KHR 0x30B5
#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_KHR 0x30B6
#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z_KHR 0x30B7
#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR 0x30B8
#endif /* EGL_KHR_gl_texture_cubemap_image */
#ifndef EGL_KHR_image
#define EGL_KHR_image 1
typedef void *EGLImageKHR;
#define EGL_NATIVE_PIXMAP_KHR 0x30B0
#define EGL_NO_IMAGE_KHR ((EGLImageKHR)0)
typedef EGLImageKHR (EGLAPIENTRYP PFNEGLCREATEIMAGEKHRPROC) (EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list);
typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYIMAGEKHRPROC) (EGLDisplay dpy, EGLImageKHR image);
#ifdef EGL_EGLEXT_PROTOTYPES
EGLAPI EGLImageKHR EGLAPIENTRY eglCreateImageKHR (EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list);
EGLAPI EGLBoolean EGLAPIENTRY eglDestroyImageKHR (EGLDisplay dpy, EGLImageKHR image);
#endif
#endif /* EGL_KHR_image */
#ifndef EGL_KHR_image_base
#define EGL_KHR_image_base 1
#define EGL_IMAGE_PRESERVED_KHR 0x30D2
#endif /* EGL_KHR_image_base */
#ifndef EGL_KHR_image_pixmap
#define EGL_KHR_image_pixmap 1
#endif /* EGL_KHR_image_pixmap */
#ifndef EGL_KHR_lock_surface
#define EGL_KHR_lock_surface 1
#define EGL_READ_SURFACE_BIT_KHR 0x0001
#define EGL_WRITE_SURFACE_BIT_KHR 0x0002
#define EGL_LOCK_SURFACE_BIT_KHR 0x0080
#define EGL_OPTIMAL_FORMAT_BIT_KHR 0x0100
#define EGL_MATCH_FORMAT_KHR 0x3043
#define EGL_FORMAT_RGB_565_EXACT_KHR 0x30C0
#define EGL_FORMAT_RGB_565_KHR 0x30C1
#define EGL_FORMAT_RGBA_8888_EXACT_KHR 0x30C2
#define EGL_FORMAT_RGBA_8888_KHR 0x30C3
#define EGL_MAP_PRESERVE_PIXELS_KHR 0x30C4
#define EGL_LOCK_USAGE_HINT_KHR 0x30C5
#define EGL_BITMAP_POINTER_KHR 0x30C6
#define EGL_BITMAP_PITCH_KHR 0x30C7
#define EGL_BITMAP_ORIGIN_KHR 0x30C8
#define EGL_BITMAP_PIXEL_RED_OFFSET_KHR 0x30C9
#define EGL_BITMAP_PIXEL_GREEN_OFFSET_KHR 0x30CA
#define EGL_BITMAP_PIXEL_BLUE_OFFSET_KHR 0x30CB
#define EGL_BITMAP_PIXEL_ALPHA_OFFSET_KHR 0x30CC
#define EGL_BITMAP_PIXEL_LUMINANCE_OFFSET_KHR 0x30CD
#define EGL_LOWER_LEFT_KHR 0x30CE
#define EGL_UPPER_LEFT_KHR 0x30CF
typedef EGLBoolean (EGLAPIENTRYP PFNEGLLOCKSURFACEKHRPROC) (EGLDisplay dpy, EGLSurface surface, const EGLint *attrib_list);
typedef EGLBoolean (EGLAPIENTRYP PFNEGLUNLOCKSURFACEKHRPROC) (EGLDisplay dpy, EGLSurface surface);
#ifdef EGL_EGLEXT_PROTOTYPES
EGLAPI EGLBoolean EGLAPIENTRY eglLockSurfaceKHR (EGLDisplay dpy, EGLSurface surface, const EGLint *attrib_list);
EGLAPI EGLBoolean EGLAPIENTRY eglUnlockSurfaceKHR (EGLDisplay dpy, EGLSurface surface);
#endif
#endif /* EGL_KHR_lock_surface */
#ifndef EGL_KHR_lock_surface2
#define EGL_KHR_lock_surface2 1
#define EGL_BITMAP_PIXEL_SIZE_KHR 0x3110
#endif /* EGL_KHR_lock_surface2 */
#ifndef EGL_KHR_lock_surface3
#define EGL_KHR_lock_surface3 1
typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYSURFACE64KHRPROC) (EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLAttribKHR *value);
#ifdef EGL_EGLEXT_PROTOTYPES
EGLAPI EGLBoolean EGLAPIENTRY eglQuerySurface64KHR (EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLAttribKHR *value);
#endif
#endif /* EGL_KHR_lock_surface3 */
#ifndef EGL_KHR_reusable_sync
#define EGL_KHR_reusable_sync 1
typedef khronos_utime_nanoseconds_t EGLTimeKHR;
#ifdef KHRONOS_SUPPORT_INT64
#define EGL_SYNC_STATUS_KHR 0x30F1
#define EGL_SIGNALED_KHR 0x30F2
#define EGL_UNSIGNALED_KHR 0x30F3
#define EGL_TIMEOUT_EXPIRED_KHR 0x30F5
#define EGL_CONDITION_SATISFIED_KHR 0x30F6
#define EGL_SYNC_TYPE_KHR 0x30F7
#define EGL_SYNC_REUSABLE_KHR 0x30FA
#define EGL_SYNC_FLUSH_COMMANDS_BIT_KHR 0x0001
#define EGL_FOREVER_KHR 0xFFFFFFFFFFFFFFFFull
#define EGL_NO_SYNC_KHR ((EGLSyncKHR)0)
typedef EGLSyncKHR (EGLAPIENTRYP PFNEGLCREATESYNCKHRPROC) (EGLDisplay dpy, EGLenum type, const EGLint *attrib_list);
typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYSYNCKHRPROC) (EGLDisplay dpy, EGLSyncKHR sync);
typedef EGLint (EGLAPIENTRYP PFNEGLCLIENTWAITSYNCKHRPROC) (EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout);
typedef EGLBoolean (EGLAPIENTRYP PFNEGLSIGNALSYNCKHRPROC) (EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode);
typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETSYNCATTRIBKHRPROC) (EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint *value);
#ifdef EGL_EGLEXT_PROTOTYPES
EGLAPI EGLSyncKHR EGLAPIENTRY eglCreateSyncKHR (EGLDisplay dpy, EGLenum type, const EGLint *attrib_list);
EGLAPI EGLBoolean EGLAPIENTRY eglDestroySyncKHR (EGLDisplay dpy, EGLSyncKHR sync);
EGLAPI EGLint EGLAPIENTRY eglClientWaitSyncKHR (EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout);
EGLAPI EGLBoolean EGLAPIENTRY eglSignalSyncKHR (EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode);
EGLAPI EGLBoolean EGLAPIENTRY eglGetSyncAttribKHR (EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint *value);
#endif
#endif /* KHRONOS_SUPPORT_INT64 */
#endif /* EGL_KHR_reusable_sync */
#ifndef EGL_KHR_stream
#define EGL_KHR_stream 1
typedef void *EGLStreamKHR;
typedef khronos_uint64_t EGLuint64KHR;
#ifdef KHRONOS_SUPPORT_INT64
#define EGL_NO_STREAM_KHR ((EGLStreamKHR)0)
#define EGL_CONSUMER_LATENCY_USEC_KHR 0x3210
#define EGL_PRODUCER_FRAME_KHR 0x3212
#define EGL_CONSUMER_FRAME_KHR 0x3213
#define EGL_STREAM_STATE_KHR 0x3214
#define EGL_STREAM_STATE_CREATED_KHR 0x3215
#define EGL_STREAM_STATE_CONNECTING_KHR 0x3216
#define EGL_STREAM_STATE_EMPTY_KHR 0x3217
#define EGL_STREAM_STATE_NEW_FRAME_AVAILABLE_KHR 0x3218
#define EGL_STREAM_STATE_OLD_FRAME_AVAILABLE_KHR 0x3219
#define EGL_STREAM_STATE_DISCONNECTED_KHR 0x321A
#define EGL_BAD_STREAM_KHR 0x321B
#define EGL_BAD_STATE_KHR 0x321C
typedef EGLStreamKHR (EGLAPIENTRYP PFNEGLCREATESTREAMKHRPROC) (EGLDisplay dpy, const EGLint *attrib_list);
typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYSTREAMKHRPROC) (EGLDisplay dpy, EGLStreamKHR stream);
typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMATTRIBKHRPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLint value);
typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYSTREAMKHRPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLint *value);
typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYSTREAMU64KHRPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLuint64KHR *value);
#ifdef EGL_EGLEXT_PROTOTYPES
EGLAPI EGLStreamKHR EGLAPIENTRY eglCreateStreamKHR (EGLDisplay dpy, const EGLint *attrib_list);
EGLAPI EGLBoolean EGLAPIENTRY eglDestroyStreamKHR (EGLDisplay dpy, EGLStreamKHR stream);
EGLAPI EGLBoolean EGLAPIENTRY eglStreamAttribKHR (EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLint value);
EGLAPI EGLBoolean EGLAPIENTRY eglQueryStreamKHR (EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLint *value);
EGLAPI EGLBoolean EGLAPIENTRY eglQueryStreamu64KHR (EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLuint64KHR *value);
#endif
#endif /* KHRONOS_SUPPORT_INT64 */
#endif /* EGL_KHR_stream */
#ifndef EGL_KHR_stream_consumer_gltexture
#define EGL_KHR_stream_consumer_gltexture 1
#ifdef EGL_KHR_stream
#define EGL_CONSUMER_ACQUIRE_TIMEOUT_USEC_KHR 0x321E
typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHRPROC) (EGLDisplay dpy, EGLStreamKHR stream);
typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMCONSUMERACQUIREKHRPROC) (EGLDisplay dpy, EGLStreamKHR stream);
typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMCONSUMERRELEASEKHRPROC) (EGLDisplay dpy, EGLStreamKHR stream);
#ifdef EGL_EGLEXT_PROTOTYPES
EGLAPI EGLBoolean EGLAPIENTRY eglStreamConsumerGLTextureExternalKHR (EGLDisplay dpy, EGLStreamKHR stream);
EGLAPI EGLBoolean EGLAPIENTRY eglStreamConsumerAcquireKHR (EGLDisplay dpy, EGLStreamKHR stream);
EGLAPI EGLBoolean EGLAPIENTRY eglStreamConsumerReleaseKHR (EGLDisplay dpy, EGLStreamKHR stream);
#endif
#endif /* EGL_KHR_stream */
#endif /* EGL_KHR_stream_consumer_gltexture */
#ifndef EGL_KHR_stream_cross_process_fd
#define EGL_KHR_stream_cross_process_fd 1
typedef int EGLNativeFileDescriptorKHR;
#ifdef EGL_KHR_stream
#define EGL_NO_FILE_DESCRIPTOR_KHR ((EGLNativeFileDescriptorKHR)(-1))
typedef EGLNativeFileDescriptorKHR (EGLAPIENTRYP PFNEGLGETSTREAMFILEDESCRIPTORKHRPROC) (EGLDisplay dpy, EGLStreamKHR stream);
typedef EGLStreamKHR (EGLAPIENTRYP PFNEGLCREATESTREAMFROMFILEDESCRIPTORKHRPROC) (EGLDisplay dpy, EGLNativeFileDescriptorKHR file_descriptor);
#ifdef EGL_EGLEXT_PROTOTYPES
EGLAPI EGLNativeFileDescriptorKHR EGLAPIENTRY eglGetStreamFileDescriptorKHR (EGLDisplay dpy, EGLStreamKHR stream);
EGLAPI EGLStreamKHR EGLAPIENTRY eglCreateStreamFromFileDescriptorKHR (EGLDisplay dpy, EGLNativeFileDescriptorKHR file_descriptor);
#endif
#endif /* EGL_KHR_stream */
#endif /* EGL_KHR_stream_cross_process_fd */
#ifndef EGL_KHR_stream_fifo
#define EGL_KHR_stream_fifo 1
#ifdef EGL_KHR_stream
#define EGL_STREAM_FIFO_LENGTH_KHR 0x31FC
#define EGL_STREAM_TIME_NOW_KHR 0x31FD
#define EGL_STREAM_TIME_CONSUMER_KHR 0x31FE
#define EGL_STREAM_TIME_PRODUCER_KHR 0x31FF
typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYSTREAMTIMEKHRPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLTimeKHR *value);
#ifdef EGL_EGLEXT_PROTOTYPES
EGLAPI EGLBoolean EGLAPIENTRY eglQueryStreamTimeKHR (EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLTimeKHR *value);
#endif
#endif /* EGL_KHR_stream */
#endif /* EGL_KHR_stream_fifo */
#ifndef EGL_KHR_stream_producer_aldatalocator
#define EGL_KHR_stream_producer_aldatalocator 1
#ifdef EGL_KHR_stream
#endif /* EGL_KHR_stream */
#endif /* EGL_KHR_stream_producer_aldatalocator */
#ifndef EGL_KHR_stream_producer_eglsurface
#define EGL_KHR_stream_producer_eglsurface 1
#ifdef EGL_KHR_stream
#define EGL_STREAM_BIT_KHR 0x0800
typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATESTREAMPRODUCERSURFACEKHRPROC) (EGLDisplay dpy, EGLConfig config, EGLStreamKHR stream, const EGLint *attrib_list);
#ifdef EGL_EGLEXT_PROTOTYPES
EGLAPI EGLSurface EGLAPIENTRY eglCreateStreamProducerSurfaceKHR (EGLDisplay dpy, EGLConfig config, EGLStreamKHR stream, const EGLint *attrib_list);
#endif
#endif /* EGL_KHR_stream */
#endif /* EGL_KHR_stream_producer_eglsurface */
#ifndef EGL_KHR_surfaceless_context
#define EGL_KHR_surfaceless_context 1
#endif /* EGL_KHR_surfaceless_context */
#ifndef EGL_KHR_vg_parent_image
#define EGL_KHR_vg_parent_image 1
#define EGL_VG_PARENT_IMAGE_KHR 0x30BA
#endif /* EGL_KHR_vg_parent_image */
#ifndef EGL_KHR_wait_sync
#define EGL_KHR_wait_sync 1
typedef EGLint (EGLAPIENTRYP PFNEGLWAITSYNCKHRPROC) (EGLDisplay dpy, EGLSyncKHR sync, EGLint flags);
#ifdef EGL_EGLEXT_PROTOTYPES
EGLAPI EGLint EGLAPIENTRY eglWaitSyncKHR (EGLDisplay dpy, EGLSyncKHR sync, EGLint flags);
#endif
#endif /* EGL_KHR_wait_sync */
#ifndef EGL_ANDROID_blob_cache
#define EGL_ANDROID_blob_cache 1
typedef khronos_ssize_t EGLsizeiANDROID;
typedef void (*EGLSetBlobFuncANDROID) (const void *key, EGLsizeiANDROID keySize, const void *value, EGLsizeiANDROID valueSize);
typedef EGLsizeiANDROID (*EGLGetBlobFuncANDROID) (const void *key, EGLsizeiANDROID keySize, void *value, EGLsizeiANDROID valueSize);
typedef void (EGLAPIENTRYP PFNEGLSETBLOBCACHEFUNCSANDROIDPROC) (EGLDisplay dpy, EGLSetBlobFuncANDROID set, EGLGetBlobFuncANDROID get);
#ifdef EGL_EGLEXT_PROTOTYPES
EGLAPI void EGLAPIENTRY eglSetBlobCacheFuncsANDROID (EGLDisplay dpy, EGLSetBlobFuncANDROID set, EGLGetBlobFuncANDROID get);
#endif
#endif /* EGL_ANDROID_blob_cache */
#ifndef EGL_ANDROID_framebuffer_target
#define EGL_ANDROID_framebuffer_target 1
#define EGL_FRAMEBUFFER_TARGET_ANDROID 0x3147
#endif /* EGL_ANDROID_framebuffer_target */
#ifndef EGL_ANDROID_image_native_buffer
#define EGL_ANDROID_image_native_buffer 1
#define EGL_NATIVE_BUFFER_ANDROID 0x3140
#endif /* EGL_ANDROID_image_native_buffer */
#ifndef EGL_ANDROID_native_fence_sync
#define EGL_ANDROID_native_fence_sync 1
#define EGL_SYNC_NATIVE_FENCE_ANDROID 0x3144
#define EGL_SYNC_NATIVE_FENCE_FD_ANDROID 0x3145
#define EGL_SYNC_NATIVE_FENCE_SIGNALED_ANDROID 0x3146
#define EGL_NO_NATIVE_FENCE_FD_ANDROID -1
typedef EGLint (EGLAPIENTRYP PFNEGLDUPNATIVEFENCEFDANDROIDPROC) (EGLDisplay dpy, EGLSyncKHR sync);
#ifdef EGL_EGLEXT_PROTOTYPES
EGLAPI EGLint EGLAPIENTRY eglDupNativeFenceFDANDROID (EGLDisplay dpy, EGLSyncKHR sync);
#endif
#endif /* EGL_ANDROID_native_fence_sync */
#ifndef EGL_ANDROID_recordable
#define EGL_ANDROID_recordable 1
#define EGL_RECORDABLE_ANDROID 0x3142
#endif /* EGL_ANDROID_recordable */
#ifndef EGL_ANGLE_d3d_share_handle_client_buffer
#define EGL_ANGLE_d3d_share_handle_client_buffer 1
#define EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE 0x3200
#endif /* EGL_ANGLE_d3d_share_handle_client_buffer */
#ifndef EGL_ANGLE_query_surface_pointer
#define EGL_ANGLE_query_surface_pointer 1
typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYSURFACEPOINTERANGLEPROC) (EGLDisplay dpy, EGLSurface surface, EGLint attribute, void **value);
#ifdef EGL_EGLEXT_PROTOTYPES
EGLAPI EGLBoolean EGLAPIENTRY eglQuerySurfacePointerANGLE (EGLDisplay dpy, EGLSurface surface, EGLint attribute, void **value);
#endif
#endif /* EGL_ANGLE_query_surface_pointer */
#ifndef EGL_ANGLE_surface_d3d_texture_2d_share_handle
#define EGL_ANGLE_surface_d3d_texture_2d_share_handle 1
#endif /* EGL_ANGLE_surface_d3d_texture_2d_share_handle */
#ifndef EGL_ARM_pixmap_multisample_discard
#define EGL_ARM_pixmap_multisample_discard 1
#define EGL_DISCARD_SAMPLES_ARM 0x3286
#endif /* EGL_ARM_pixmap_multisample_discard */
#ifndef EGL_EXT_buffer_age
#define EGL_EXT_buffer_age 1
#define EGL_BUFFER_AGE_EXT 0x313D
#endif /* EGL_EXT_buffer_age */
#ifndef EGL_EXT_client_extensions
#define EGL_EXT_client_extensions 1
#endif /* EGL_EXT_client_extensions */
#ifndef EGL_EXT_create_context_robustness
#define EGL_EXT_create_context_robustness 1
#define EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT 0x30BF
#define EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT 0x3138
#define EGL_NO_RESET_NOTIFICATION_EXT 0x31BE
#define EGL_LOSE_CONTEXT_ON_RESET_EXT 0x31BF
#endif /* EGL_EXT_create_context_robustness */
#ifndef EGL_EXT_image_dma_buf_import
#define EGL_EXT_image_dma_buf_import 1
#define EGL_LINUX_DMA_BUF_EXT 0x3270
#define EGL_LINUX_DRM_FOURCC_EXT 0x3271
#define EGL_DMA_BUF_PLANE0_FD_EXT 0x3272
#define EGL_DMA_BUF_PLANE0_OFFSET_EXT 0x3273
#define EGL_DMA_BUF_PLANE0_PITCH_EXT 0x3274
#define EGL_DMA_BUF_PLANE1_FD_EXT 0x3275
#define EGL_DMA_BUF_PLANE1_OFFSET_EXT 0x3276
#define EGL_DMA_BUF_PLANE1_PITCH_EXT 0x3277
#define EGL_DMA_BUF_PLANE2_FD_EXT 0x3278
#define EGL_DMA_BUF_PLANE2_OFFSET_EXT 0x3279
#define EGL_DMA_BUF_PLANE2_PITCH_EXT 0x327A
#define EGL_YUV_COLOR_SPACE_HINT_EXT 0x327B
#define EGL_SAMPLE_RANGE_HINT_EXT 0x327C
#define EGL_YUV_CHROMA_HORIZONTAL_SITING_HINT_EXT 0x327D
#define EGL_YUV_CHROMA_VERTICAL_SITING_HINT_EXT 0x327E
#define EGL_ITU_REC601_EXT 0x327F
#define EGL_ITU_REC709_EXT 0x3280
#define EGL_ITU_REC2020_EXT 0x3281
#define EGL_YUV_FULL_RANGE_EXT 0x3282
#define EGL_YUV_NARROW_RANGE_EXT 0x3283
#define EGL_YUV_CHROMA_SITING_0_EXT 0x3284
#define EGL_YUV_CHROMA_SITING_0_5_EXT 0x3285
#endif /* EGL_EXT_image_dma_buf_import */
#ifndef EGL_EXT_multiview_window
#define EGL_EXT_multiview_window 1
#define EGL_MULTIVIEW_VIEW_COUNT_EXT 0x3134
#endif /* EGL_EXT_multiview_window */
#ifndef EGL_EXT_platform_base
#define EGL_EXT_platform_base 1
typedef EGLDisplay (EGLAPIENTRYP PFNEGLGETPLATFORMDISPLAYEXTPROC) (EGLenum platform, void *native_display, const EGLint *attrib_list);
typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC) (EGLDisplay dpy, EGLConfig config, void *native_window, const EGLint *attrib_list);
typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATEPLATFORMPIXMAPSURFACEEXTPROC) (EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLint *attrib_list);
#ifdef EGL_EGLEXT_PROTOTYPES
EGLAPI EGLDisplay EGLAPIENTRY eglGetPlatformDisplayEXT (EGLenum platform, void *native_display, const EGLint *attrib_list);
EGLAPI EGLSurface EGLAPIENTRY eglCreatePlatformWindowSurfaceEXT (EGLDisplay dpy, EGLConfig config, void *native_window, const EGLint *attrib_list);
EGLAPI EGLSurface EGLAPIENTRY eglCreatePlatformPixmapSurfaceEXT (EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLint *attrib_list);
#endif
#endif /* EGL_EXT_platform_base */
#ifndef EGL_EXT_platform_wayland
#define EGL_EXT_platform_wayland 1
#define EGL_PLATFORM_WAYLAND_EXT 0x31D8
#endif /* EGL_EXT_platform_wayland */
#ifndef EGL_EXT_platform_x11
#define EGL_EXT_platform_x11 1
#define EGL_PLATFORM_X11_EXT 0x31D5
#define EGL_PLATFORM_X11_SCREEN_EXT 0x31D6
#endif /* EGL_EXT_platform_x11 */
#ifndef EGL_EXT_swap_buffers_with_damage
#define EGL_EXT_swap_buffers_with_damage 1
typedef EGLBoolean (EGLAPIENTRYP PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC) (EGLDisplay dpy, EGLSurface surface, EGLint *rects, EGLint n_rects);
#ifdef EGL_EGLEXT_PROTOTYPES
EGLAPI EGLBoolean EGLAPIENTRY eglSwapBuffersWithDamageEXT (EGLDisplay dpy, EGLSurface surface, EGLint *rects, EGLint n_rects);
#endif
#endif /* EGL_EXT_swap_buffers_with_damage */
#ifndef EGL_HI_clientpixmap
#define EGL_HI_clientpixmap 1
struct EGLClientPixmapHI {
void *pData;
EGLint iWidth;
EGLint iHeight;
EGLint iStride;
};
#define EGL_CLIENT_PIXMAP_POINTER_HI 0x8F74
typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATEPIXMAPSURFACEHIPROC) (EGLDisplay dpy, EGLConfig config, struct EGLClientPixmapHI *pixmap);
#ifdef EGL_EGLEXT_PROTOTYPES
EGLAPI EGLSurface EGLAPIENTRY eglCreatePixmapSurfaceHI (EGLDisplay dpy, EGLConfig config, struct EGLClientPixmapHI *pixmap);
#endif
#endif /* EGL_HI_clientpixmap */
#ifndef EGL_HI_colorformats
#define EGL_HI_colorformats 1
#define EGL_COLOR_FORMAT_HI 0x8F70
#define EGL_COLOR_RGB_HI 0x8F71
#define EGL_COLOR_RGBA_HI 0x8F72
#define EGL_COLOR_ARGB_HI 0x8F73
#endif /* EGL_HI_colorformats */
#ifndef EGL_IMG_context_priority
#define EGL_IMG_context_priority 1
#define EGL_CONTEXT_PRIORITY_LEVEL_IMG 0x3100
#define EGL_CONTEXT_PRIORITY_HIGH_IMG 0x3101
#define EGL_CONTEXT_PRIORITY_MEDIUM_IMG 0x3102
#define EGL_CONTEXT_PRIORITY_LOW_IMG 0x3103
#endif /* EGL_IMG_context_priority */
#ifndef EGL_MESA_drm_image
#define EGL_MESA_drm_image 1
#define EGL_DRM_BUFFER_FORMAT_MESA 0x31D0
#define EGL_DRM_BUFFER_USE_MESA 0x31D1
#define EGL_DRM_BUFFER_FORMAT_ARGB32_MESA 0x31D2
#define EGL_DRM_BUFFER_MESA 0x31D3
#define EGL_DRM_BUFFER_STRIDE_MESA 0x31D4
#define EGL_DRM_BUFFER_USE_SCANOUT_MESA 0x00000001
#define EGL_DRM_BUFFER_USE_SHARE_MESA 0x00000002
typedef EGLImageKHR (EGLAPIENTRYP PFNEGLCREATEDRMIMAGEMESAPROC) (EGLDisplay dpy, const EGLint *attrib_list);
typedef EGLBoolean (EGLAPIENTRYP PFNEGLEXPORTDRMIMAGEMESAPROC) (EGLDisplay dpy, EGLImageKHR image, EGLint *name, EGLint *handle, EGLint *stride);
#ifdef EGL_EGLEXT_PROTOTYPES
EGLAPI EGLImageKHR EGLAPIENTRY eglCreateDRMImageMESA (EGLDisplay dpy, const EGLint *attrib_list);
EGLAPI EGLBoolean EGLAPIENTRY eglExportDRMImageMESA (EGLDisplay dpy, EGLImageKHR image, EGLint *name, EGLint *handle, EGLint *stride);
#endif
#endif /* EGL_MESA_drm_image */
#ifndef EGL_MESA_platform_gbm
#define EGL_MESA_platform_gbm 1
#define EGL_PLATFORM_GBM_MESA 0x31D7
#endif /* EGL_MESA_platform_gbm */
#ifndef EGL_NV_3dvision_surface
#define EGL_NV_3dvision_surface 1
#define EGL_AUTO_STEREO_NV 0x3136
#endif /* EGL_NV_3dvision_surface */
#ifndef EGL_NV_coverage_sample
#define EGL_NV_coverage_sample 1
#define EGL_COVERAGE_BUFFERS_NV 0x30E0
#define EGL_COVERAGE_SAMPLES_NV 0x30E1
#endif /* EGL_NV_coverage_sample */
#ifndef EGL_NV_coverage_sample_resolve
#define EGL_NV_coverage_sample_resolve 1
#define EGL_COVERAGE_SAMPLE_RESOLVE_NV 0x3131
#define EGL_COVERAGE_SAMPLE_RESOLVE_DEFAULT_NV 0x3132
#define EGL_COVERAGE_SAMPLE_RESOLVE_NONE_NV 0x3133
#endif /* EGL_NV_coverage_sample_resolve */
#ifndef EGL_NV_depth_nonlinear
#define EGL_NV_depth_nonlinear 1
#define EGL_DEPTH_ENCODING_NV 0x30E2
#define EGL_DEPTH_ENCODING_NONE_NV 0
#define EGL_DEPTH_ENCODING_NONLINEAR_NV 0x30E3
#endif /* EGL_NV_depth_nonlinear */
#ifndef EGL_NV_native_query
#define EGL_NV_native_query 1
typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYNATIVEDISPLAYNVPROC) (EGLDisplay dpy, EGLNativeDisplayType *display_id);
typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYNATIVEWINDOWNVPROC) (EGLDisplay dpy, EGLSurface surf, EGLNativeWindowType *window);
typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYNATIVEPIXMAPNVPROC) (EGLDisplay dpy, EGLSurface surf, EGLNativePixmapType *pixmap);
#ifdef EGL_EGLEXT_PROTOTYPES
EGLAPI EGLBoolean EGLAPIENTRY eglQueryNativeDisplayNV (EGLDisplay dpy, EGLNativeDisplayType *display_id);
EGLAPI EGLBoolean EGLAPIENTRY eglQueryNativeWindowNV (EGLDisplay dpy, EGLSurface surf, EGLNativeWindowType *window);
EGLAPI EGLBoolean EGLAPIENTRY eglQueryNativePixmapNV (EGLDisplay dpy, EGLSurface surf, EGLNativePixmapType *pixmap);
#endif
#endif /* EGL_NV_native_query */
#ifndef EGL_NV_post_convert_rounding
#define EGL_NV_post_convert_rounding 1
#endif /* EGL_NV_post_convert_rounding */
#ifndef EGL_NV_post_sub_buffer
#define EGL_NV_post_sub_buffer 1
#define EGL_POST_SUB_BUFFER_SUPPORTED_NV 0x30BE
typedef EGLBoolean (EGLAPIENTRYP PFNEGLPOSTSUBBUFFERNVPROC) (EGLDisplay dpy, EGLSurface surface, EGLint x, EGLint y, EGLint width, EGLint height);
#ifdef EGL_EGLEXT_PROTOTYPES
EGLAPI EGLBoolean EGLAPIENTRY eglPostSubBufferNV (EGLDisplay dpy, EGLSurface surface, EGLint x, EGLint y, EGLint width, EGLint height);
#endif
#endif /* EGL_NV_post_sub_buffer */
#ifndef EGL_NV_stream_sync
#define EGL_NV_stream_sync 1
#define EGL_SYNC_NEW_FRAME_NV 0x321F
typedef EGLSyncKHR (EGLAPIENTRYP PFNEGLCREATESTREAMSYNCNVPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLenum type, const EGLint *attrib_list);
#ifdef EGL_EGLEXT_PROTOTYPES
EGLAPI EGLSyncKHR EGLAPIENTRY eglCreateStreamSyncNV (EGLDisplay dpy, EGLStreamKHR stream, EGLenum type, const EGLint *attrib_list);
#endif
#endif /* EGL_NV_stream_sync */
#ifndef EGL_NV_sync
#define EGL_NV_sync 1
typedef void *EGLSyncNV;
typedef khronos_utime_nanoseconds_t EGLTimeNV;
#ifdef KHRONOS_SUPPORT_INT64
#define EGL_SYNC_PRIOR_COMMANDS_COMPLETE_NV 0x30E6
#define EGL_SYNC_STATUS_NV 0x30E7
#define EGL_SIGNALED_NV 0x30E8
#define EGL_UNSIGNALED_NV 0x30E9
#define EGL_SYNC_FLUSH_COMMANDS_BIT_NV 0x0001
#define EGL_FOREVER_NV 0xFFFFFFFFFFFFFFFFull
#define EGL_ALREADY_SIGNALED_NV 0x30EA
#define EGL_TIMEOUT_EXPIRED_NV 0x30EB
#define EGL_CONDITION_SATISFIED_NV 0x30EC
#define EGL_SYNC_TYPE_NV 0x30ED
#define EGL_SYNC_CONDITION_NV 0x30EE
#define EGL_SYNC_FENCE_NV 0x30EF
#define EGL_NO_SYNC_NV ((EGLSyncNV)0)
typedef EGLSyncNV (EGLAPIENTRYP PFNEGLCREATEFENCESYNCNVPROC) (EGLDisplay dpy, EGLenum condition, const EGLint *attrib_list);
typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYSYNCNVPROC) (EGLSyncNV sync);
typedef EGLBoolean (EGLAPIENTRYP PFNEGLFENCENVPROC) (EGLSyncNV sync);
typedef EGLint (EGLAPIENTRYP PFNEGLCLIENTWAITSYNCNVPROC) (EGLSyncNV sync, EGLint flags, EGLTimeNV timeout);
typedef EGLBoolean (EGLAPIENTRYP PFNEGLSIGNALSYNCNVPROC) (EGLSyncNV sync, EGLenum mode);
typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETSYNCATTRIBNVPROC) (EGLSyncNV sync, EGLint attribute, EGLint *value);
#ifdef EGL_EGLEXT_PROTOTYPES
EGLAPI EGLSyncNV EGLAPIENTRY eglCreateFenceSyncNV (EGLDisplay dpy, EGLenum condition, const EGLint *attrib_list);
EGLAPI EGLBoolean EGLAPIENTRY eglDestroySyncNV (EGLSyncNV sync);
EGLAPI EGLBoolean EGLAPIENTRY eglFenceNV (EGLSyncNV sync);
EGLAPI EGLint EGLAPIENTRY eglClientWaitSyncNV (EGLSyncNV sync, EGLint flags, EGLTimeNV timeout);
EGLAPI EGLBoolean EGLAPIENTRY eglSignalSyncNV (EGLSyncNV sync, EGLenum mode);
EGLAPI EGLBoolean EGLAPIENTRY eglGetSyncAttribNV (EGLSyncNV sync, EGLint attribute, EGLint *value);
#endif
#endif /* KHRONOS_SUPPORT_INT64 */
#endif /* EGL_NV_sync */
#ifndef EGL_NV_system_time
#define EGL_NV_system_time 1
typedef khronos_utime_nanoseconds_t EGLuint64NV;
#ifdef KHRONOS_SUPPORT_INT64
typedef EGLuint64NV (EGLAPIENTRYP PFNEGLGETSYSTEMTIMEFREQUENCYNVPROC) (void);
typedef EGLuint64NV (EGLAPIENTRYP PFNEGLGETSYSTEMTIMENVPROC) (void);
#ifdef EGL_EGLEXT_PROTOTYPES
EGLAPI EGLuint64NV EGLAPIENTRY eglGetSystemTimeFrequencyNV (void);
EGLAPI EGLuint64NV EGLAPIENTRY eglGetSystemTimeNV (void);
#endif
#endif /* KHRONOS_SUPPORT_INT64 */
#endif /* EGL_NV_system_time */
#ifdef __cplusplus
}
#endif
#endif
projects/hip/amdocl/EGL/eglplatform.h
+125
View File
@@ -0,0 +1,125 @@
#ifndef __eglplatform_h_
#define __eglplatform_h_
/*
** Copyright (c) 2007-2013 The Khronos Group Inc.
**
** Permission is hereby granted, free of charge, to any person obtaining a
** copy of this software and/or associated documentation files (the
** "Materials"), to deal in the Materials without restriction, including
** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Materials, and to
** permit persons to whom the Materials are furnished to do so, subject to
** the following conditions:
**
** The above copyright notice and this permission notice shall be included
** in all copies or substantial portions of the Materials.
**
** THE MATERIALS ARE 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 AUTHORS 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
** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
*/
/* Platform-specific types and definitions for egl.h
* $Revision: 23432 $ on $Date: 2013-10-09 00:57:24 -0700 (Wed, 09 Oct 2013) $
*
* Adopters may modify khrplatform.h and this file to suit their platform.
* You are encouraged to submit all modifications to the Khronos group so that
* they can be included in future versions of this file. Please submit changes
* by sending them to the public Khronos Bugzilla (http://khronos.org/bugzilla)
* by filing a bug against product "EGL" component "Registry".
*/
#include <KHR/khrplatform.h>
/* Macros used in EGL function prototype declarations.
*
* EGL functions should be prototyped as:
*
* EGLAPI return-type EGLAPIENTRY eglFunction(arguments);
* typedef return-type (EXPAPIENTRYP PFNEGLFUNCTIONPROC) (arguments);
*
* KHRONOS_APICALL and KHRONOS_APIENTRY are defined in KHR/khrplatform.h
*/
#ifndef EGLAPI
#define EGLAPI KHRONOS_APICALL
#endif
#ifndef EGLAPIENTRY
#define EGLAPIENTRY KHRONOS_APIENTRY
#endif
#define EGLAPIENTRYP EGLAPIENTRY*
/* The types NativeDisplayType, NativeWindowType, and NativePixmapType
* are aliases of window-system-dependent types, such as X Display * or
* Windows Device Context. They must be defined in platform-specific
* code below. The EGL-prefixed versions of Native*Type are the same
* types, renamed in EGL 1.3 so all types in the API start with "EGL".
*
* Khronos STRONGLY RECOMMENDS that you use the default definitions
* provided below, since these changes affect both binary and source
* portability of applications using EGL running on different EGL
* implementations.
*/
#if defined(_WIN32) || defined(__VC32__) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) /* Win32 and WinCE */
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN 1
#endif
#include <windows.h>
typedef HDC EGLNativeDisplayType;
typedef HBITMAP EGLNativePixmapType;
typedef HWND EGLNativeWindowType;
#elif defined(__WINSCW__) || defined(__SYMBIAN32__) /* Symbian */
typedef int EGLNativeDisplayType;
typedef void *EGLNativeWindowType;
typedef void *EGLNativePixmapType;
#elif defined(__ANDROID__) || defined(ANDROID)
#include <android/native_window.h>
struct egl_native_pixmap_t;
typedef struct ANativeWindow* EGLNativeWindowType;
typedef struct egl_native_pixmap_t* EGLNativePixmapType;
typedef void* EGLNativeDisplayType;
#elif defined(__unix__)
/* X11 (tentative) */
#include <X11/Xlib.h>
#include <X11/Xutil.h>
typedef Display *EGLNativeDisplayType;
typedef Pixmap EGLNativePixmapType;
typedef Window EGLNativeWindowType;
#else
#error "Platform not recognized"
#endif
/* EGL 1.2 types, renamed for consistency in EGL 1.3 */
typedef EGLNativeDisplayType NativeDisplayType;
typedef EGLNativePixmapType NativePixmapType;
typedef EGLNativeWindowType NativeWindowType;
/* Define EGLint. This must be a signed integral type large enough to contain
* all legal attribute names and values passed into and out of EGL, whether
* their type is boolean, bitmask, enumerant (symbolic constant), integer,
* handle, or other. While in general a 32-bit integer will suffice, if
* handles are 64 bit types, then EGLint should be defined as a signed 64-bit
* integer type.
*/
typedef khronos_int32_t EGLint;
#endif /* __eglplatform_h */
projects/hip/amdocl/KHR/khrplatform.h
+282
View File
@@ -0,0 +1,282 @@
#ifndef __khrplatform_h_
#define __khrplatform_h_
/*
** Copyright (c) 2008-2009 The Khronos Group Inc.
**
** Permission is hereby granted, free of charge, to any person obtaining a
** copy of this software and/or associated documentation files (the
** "Materials"), to deal in the Materials without restriction, including
** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Materials, and to
** permit persons to whom the Materials are furnished to do so, subject to
** the following conditions:
**
** The above copyright notice and this permission notice shall be included
** in all copies or substantial portions of the Materials.
**
** THE MATERIALS ARE 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 AUTHORS 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
** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
*/
/* Khronos platform-specific types and definitions.
*
* $Revision: 23298 $ on $Date: 2013-09-30 17:07:13 -0700 (Mon, 30 Sep 2013) $
*
* Adopters may modify this file to suit their platform. Adopters are
* encouraged to submit platform specific modifications to the Khronos
* group so that they can be included in future versions of this file.
* Please submit changes by sending them to the public Khronos Bugzilla
* (http://khronos.org/bugzilla) by filing a bug against product
* "Khronos (general)" component "Registry".
*
* A predefined template which fills in some of the bug fields can be
* reached using http://tinyurl.com/khrplatform-h-bugreport, but you
* must create a Bugzilla login first.
*
*
* See the Implementer's Guidelines for information about where this file
* should be located on your system and for more details of its use:
* http://www.khronos.org/registry/implementers_guide.pdf
*
* This file should be included as
* #include <KHR/khrplatform.h>
* by Khronos client API header files that use its types and defines.
*
* The types in khrplatform.h should only be used to define API-specific types.
*
* Types defined in khrplatform.h:
* khronos_int8_t signed 8 bit
* khronos_uint8_t unsigned 8 bit
* khronos_int16_t signed 16 bit
* khronos_uint16_t unsigned 16 bit
* khronos_int32_t signed 32 bit
* khronos_uint32_t unsigned 32 bit
* khronos_int64_t signed 64 bit
* khronos_uint64_t unsigned 64 bit
* khronos_intptr_t signed same number of bits as a pointer
* khronos_uintptr_t unsigned same number of bits as a pointer
* khronos_ssize_t signed size
* khronos_usize_t unsigned size
* khronos_float_t signed 32 bit floating point
* khronos_time_ns_t unsigned 64 bit time in nanoseconds
* khronos_utime_nanoseconds_t unsigned time interval or absolute time in
* nanoseconds
* khronos_stime_nanoseconds_t signed time interval in nanoseconds
* khronos_boolean_enum_t enumerated boolean type. This should
* only be used as a base type when a client API's boolean type is
* an enum. Client APIs which use an integer or other type for
* booleans cannot use this as the base type for their boolean.
*
* Tokens defined in khrplatform.h:
*
* KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values.
*
* KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0.
* KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0.
*
* Calling convention macros defined in this file:
* KHRONOS_APICALL
* KHRONOS_APIENTRY
* KHRONOS_APIATTRIBUTES
*
* These may be used in function prototypes as:
*
* KHRONOS_APICALL void KHRONOS_APIENTRY funcname(
* int arg1,
* int arg2) KHRONOS_APIATTRIBUTES;
*/
/*-------------------------------------------------------------------------
* Definition of KHRONOS_APICALL
*-------------------------------------------------------------------------
* This precedes the return type of the function in the function prototype.
*/
#if defined(_WIN32) && !defined(__SCITECH_SNAP__)
# define KHRONOS_APICALL __declspec(dllimport)
#elif defined (__SYMBIAN32__)
# define KHRONOS_APICALL IMPORT_C
#else
# define KHRONOS_APICALL
#endif
/*-------------------------------------------------------------------------
* Definition of KHRONOS_APIENTRY
*-------------------------------------------------------------------------
* This follows the return type of the function and precedes the function
* name in the function prototype.
*/
#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__)
/* Win32 but not WinCE */
# define KHRONOS_APIENTRY __stdcall
#else
# define KHRONOS_APIENTRY
#endif
/*-------------------------------------------------------------------------
* Definition of KHRONOS_APIATTRIBUTES
*-------------------------------------------------------------------------
* This follows the closing parenthesis of the function prototype arguments.
*/
#if defined (__ARMCC_2__)
#define KHRONOS_APIATTRIBUTES __softfp
#else
#define KHRONOS_APIATTRIBUTES
#endif
/*-------------------------------------------------------------------------
* basic type definitions
*-----------------------------------------------------------------------*/
#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__)
/*
* Using <stdint.h>
*/
#include <stdint.h>
typedef int32_t khronos_int32_t;
typedef uint32_t khronos_uint32_t;
typedef int64_t khronos_int64_t;
typedef uint64_t khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#elif defined(__VMS ) || defined(__sgi)
/*
* Using <inttypes.h>
*/
#include <inttypes.h>
typedef int32_t khronos_int32_t;
typedef uint32_t khronos_uint32_t;
typedef int64_t khronos_int64_t;
typedef uint64_t khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#elif defined(_WIN32) && !defined(__SCITECH_SNAP__)
/*
* Win32
*/
typedef __int32 khronos_int32_t;
typedef unsigned __int32 khronos_uint32_t;
typedef __int64 khronos_int64_t;
typedef unsigned __int64 khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#elif defined(__sun__) || defined(__digital__)
/*
* Sun or Digital
*/
typedef int khronos_int32_t;
typedef unsigned int khronos_uint32_t;
#if defined(__arch64__) || defined(_LP64)
typedef long int khronos_int64_t;
typedef unsigned long int khronos_uint64_t;
#else
typedef long long int khronos_int64_t;
typedef unsigned long long int khronos_uint64_t;
#endif /* __arch64__ */
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#elif 0
/*
* Hypothetical platform with no float or int64 support
*/
typedef int khronos_int32_t;
typedef unsigned int khronos_uint32_t;
#define KHRONOS_SUPPORT_INT64 0
#define KHRONOS_SUPPORT_FLOAT 0
#else
/*
* Generic fallback
*/
#include <stdint.h>
typedef int32_t khronos_int32_t;
typedef uint32_t khronos_uint32_t;
typedef int64_t khronos_int64_t;
typedef uint64_t khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#endif
/*
* Types that are (so far) the same on all platforms
*/
typedef signed char khronos_int8_t;
typedef unsigned char khronos_uint8_t;
typedef signed short int khronos_int16_t;
typedef unsigned short int khronos_uint16_t;
/*
* Types that differ between LLP64 and LP64 architectures - in LLP64,
* pointers are 64 bits, but 'long' is still 32 bits. Win64 appears
* to be the only LLP64 architecture in current use.
*/
#ifdef _WIN64
typedef signed long long int khronos_intptr_t;
typedef unsigned long long int khronos_uintptr_t;
typedef signed long long int khronos_ssize_t;
typedef unsigned long long int khronos_usize_t;
#else
typedef signed long int khronos_intptr_t;
typedef unsigned long int khronos_uintptr_t;
typedef signed long int khronos_ssize_t;
typedef unsigned long int khronos_usize_t;
#endif
#if KHRONOS_SUPPORT_FLOAT
/*
* Float type
*/
typedef float khronos_float_t;
#endif
#if KHRONOS_SUPPORT_INT64
/* Time types
*
* These types can be used to represent a time interval in nanoseconds or
* an absolute Unadjusted System Time. Unadjusted System Time is the number
* of nanoseconds since some arbitrary system event (e.g. since the last
* time the system booted). The Unadjusted System Time is an unsigned
* 64 bit value that wraps back to 0 every 584 years. Time intervals
* may be either signed or unsigned.
*/
typedef khronos_uint64_t khronos_utime_nanoseconds_t;
typedef khronos_int64_t khronos_stime_nanoseconds_t;
#endif
/*
* Dummy value used to pad enum types to 32 bits.
*/
#ifndef KHRONOS_MAX_ENUM
#define KHRONOS_MAX_ENUM 0x7FFFFFFF
#endif
/*
* Enumerated boolean type
*
* Values other than zero should be considered to be true. Therefore
* comparisons should not be made against KHRONOS_TRUE.
*/
typedef enum {
KHRONOS_FALSE = 0,
KHRONOS_TRUE = 1,
KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM
} khronos_boolean_enum_t;
#endif /* __khrplatform_h_ */
projects/hip/amdocl/cl_common.hpp
+285
View File
@@ -0,0 +1,285 @@
//
// Copyright (c) 2008 Advanced Micro Devices, Inc. All rights reserved.
//
#ifndef CL_COMMON_HPP_
#define CL_COMMON_HPP_
#include "top.hpp"
#include "platform/runtime.hpp"
#include "platform/command.hpp"
#include "platform/memory.hpp"
#include "thread/thread.hpp"
#include "platform/commandqueue.hpp"
#include <vector>
#include <utility>
//! \cond ignore
namespace amd {
template <typename T>
class NotNullWrapper
{
private:
T* const ptrOrNull_;
protected:
explicit NotNullWrapper(T* ptrOrNull)
: ptrOrNull_(ptrOrNull)
{ }
public:
void operator = (T value) const
{
if (ptrOrNull_ != NULL) {
*ptrOrNull_ = value;
}
}
};
template <typename T>
class NotNullReference : protected NotNullWrapper<T>
{
public:
explicit NotNullReference(T* ptrOrNull)
: NotNullWrapper<T>(ptrOrNull)
{ }
const NotNullWrapper<T>& operator * () const { return *this; }
};
} // namespace amd
template <typename T>
inline amd::NotNullReference<T>
not_null(T* ptrOrNull)
{
return amd::NotNullReference<T>(ptrOrNull);
}
#define CL_CHECK_THREAD(thread) \
(thread != NULL || ((thread = new amd::HostThread()) != NULL \
&& thread == amd::Thread::current()))
#define RUNTIME_ENTRY_RET(ret, func, args) \
CL_API_ENTRY ret CL_API_CALL \
func args \
{ \
amd::Thread* thread = amd::Thread::current(); \
if (!CL_CHECK_THREAD(thread)) { \
*not_null(errcode_ret) = CL_OUT_OF_HOST_MEMORY; \
return (ret) 0; \
}
#define RUNTIME_ENTRY_RET_NOERRCODE(ret, func, args) \
CL_API_ENTRY ret CL_API_CALL \
func args \
{ \
amd::Thread* thread = amd::Thread::current(); \
if (!CL_CHECK_THREAD(thread)) { \
return (ret) 0; \
}
#define RUNTIME_ENTRY(ret, func, args) \
CL_API_ENTRY ret CL_API_CALL \
func args \
{ \
amd::Thread* thread = amd::Thread::current(); \
if (!CL_CHECK_THREAD(thread)) { \
return CL_OUT_OF_HOST_MEMORY; \
}
#define RUNTIME_ENTRY_VOID(ret, func, args) \
CL_API_ENTRY ret CL_API_CALL \
func args \
{ \
amd::Thread* thread = amd::Thread::current(); \
if (!CL_CHECK_THREAD(thread)) { \
return; \
}
#define RUNTIME_EXIT \
/* FIXME_lmoriche: we should check to thread->lastError here! */ \
}
//! Helper function to check "properties" parameter in various functions
int checkContextProperties(
const cl_context_properties *properties,
bool* offlineDevices);
namespace amd {
namespace detail {
template <typename T>
struct ParamInfo
{
static inline std::pair<const void*, size_t> get(const T& param) {
return std::pair<const void*, size_t>(&param, sizeof(T));
}
};
template <>
struct ParamInfo<const char*>
{
static inline std::pair<const void*, size_t> get(const char* param) {
return std::pair<const void*, size_t>(param, strlen(param) + 1);
}
};
template <int N>
struct ParamInfo<char[N]>
{
static inline std::pair<const void*, size_t> get(const char* param) {
return std::pair<const void*, size_t>(param, strlen(param) + 1);
}
};
} // namespace detail
template <typename T>
static inline cl_int
clGetInfo(
T& field,
size_t param_value_size,
void* param_value,
size_t* param_value_size_ret)
{
const void *valuePtr;
size_t valueSize;
std::tie(valuePtr, valueSize)
= detail::ParamInfo<typename std::remove_const<T>::type>::get(field);
*not_null(param_value_size_ret) = valueSize;
cl_int ret = CL_SUCCESS;
if (param_value != NULL && param_value_size < valueSize) {
if (!std::is_pointer<T>() || !std::is_same<typename std::remove_const<
typename std::remove_pointer<T>::type>::type, char>()) {
return CL_INVALID_VALUE;
}
// For char* and char[] params, we will at least fill up to
// param_value_size, then return an error.
valueSize = param_value_size;
static_cast<char*>(param_value)[--valueSize] = '\0';
ret = CL_INVALID_VALUE;
}
if (param_value != NULL) {
::memcpy(param_value, valuePtr, valueSize);
if (param_value_size > valueSize) {
::memset(static_cast<address>(param_value) + valueSize,
'\0', param_value_size - valueSize);
}
}
return ret;
}
static inline cl_int
clSetEventWaitList(
Command::EventWaitList& eventWaitList,
const amd::HostQueue& hostQueue,
cl_uint num_events_in_wait_list,
const cl_event* event_wait_list)
{
if ((num_events_in_wait_list == 0 && event_wait_list != NULL)
|| (num_events_in_wait_list != 0 && event_wait_list == NULL)) {
return CL_INVALID_EVENT_WAIT_LIST;
}
while (num_events_in_wait_list-- > 0) {
cl_event event = *event_wait_list++;
Event* amdEvent = as_amd(event);
if (!is_valid(event)) {
return CL_INVALID_EVENT_WAIT_LIST;
}
if (&hostQueue.context() != &amdEvent->context()) {
return CL_INVALID_CONTEXT;
}
if ((amdEvent->command().queue() != &hostQueue) && !amdEvent->notifyCmdQueue()) {
return CL_INVALID_EVENT_WAIT_LIST;
}
eventWaitList.push_back(amdEvent);
}
return CL_SUCCESS;
}
//! Common function declarations for CL-external graphics API interop
cl_int clEnqueueAcquireExtObjectsAMD(cl_command_queue command_queue,
cl_uint num_objects, const cl_mem* mem_objects,
cl_uint num_events_in_wait_list, const cl_event* event_wait_list,
cl_event* event, cl_command_type cmd_type);
cl_int clEnqueueReleaseExtObjectsAMD(cl_command_queue command_queue,
cl_uint num_objects, const cl_mem* mem_objects,
cl_uint num_events_in_wait_list, const cl_event* event_wait_list,
cl_event* event, cl_command_type cmd_type);
// This may need moving somewhere tidier...
struct PlatformIDS { const struct KHRicdVendorDispatchRec* dispatch_; };
class PlatformID {
public:
static PlatformIDS Platform;
};
#define AMD_PLATFORM (reinterpret_cast<cl_platform_id>(&amd::PlatformID::Platform))
} // namespace amd
extern "C" {
extern CL_API_ENTRY cl_key_amd CL_API_CALL
clCreateKeyAMD(
cl_platform_id platform,
void (CL_CALLBACK * destructor)( void * ),
cl_int * errcode_ret);
extern CL_API_ENTRY cl_int CL_API_CALL
clObjectGetValueForKeyAMD(
void * object,
cl_key_amd key,
void ** ret_val);
extern CL_API_ENTRY cl_int CL_API_CALL
clObjectSetValueForKeyAMD(
void * object,
cl_key_amd key,
void * value);
#if defined(CL_VERSION_1_1)
extern CL_API_ENTRY cl_int CL_API_CALL
clSetCommandQueueProperty(
cl_command_queue command_queue,
cl_command_queue_properties properties,
cl_bool enable,
cl_command_queue_properties *old_properties) CL_API_SUFFIX__VERSION_1_0;
#endif // CL_VERSION_1_1
extern CL_API_ENTRY cl_mem CL_API_CALL
clConvertImageAMD(
cl_context context,
cl_mem image,
const cl_image_format * image_format,
cl_int * errcode_ret);
extern CL_API_ENTRY cl_mem CL_API_CALL
clCreateBufferFromImageAMD(
cl_context context,
cl_mem image,
cl_int * errcode_ret);
extern CL_API_ENTRY cl_program CL_API_CALL
clCreateProgramWithAssemblyAMD(
cl_context context,
cl_uint count,
const char ** strings,
const size_t * lengths,
cl_int * errcode_ret);
} // extern "C"
//! \endcond
#endif /*CL_COMMON_HPP_*/
projects/hip/amdocl/cl_debugger_amd.h
+678
View File
@@ -0,0 +1,678 @@
//
// Copyright (c) 2014 Advanced Micro Devices, Inc. All rights reserved.
//
#ifndef __CL_DEBUGGER_AMD_H
#define __CL_DEBUGGER_AMD_H
#ifdef __APPLE__
#include <OpenCL/cl_platform.h>
#else
#include <CL/cl_platform.h>
#endif
/******************************************
* Private AMD extension cl_dbg *
******************************************/
#ifdef __cplusplus
extern "C" {
#endif /*__cplusplus*/
#define CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD -80
#define CL_DEBUGGER_REGISTER_FAILURE_AMD -81
#define CL_TRAP_HANDLER_NOT_DEFINED_AMD -82
#define CL_EVENT_TIMEOUT_AMD -83
typedef uintptr_t cl_dbg_event_amd; //! debug event
/*! \brief Trap Handler Type
*
* The trap handler for each support type.
*/
enum cl_dbg_trap_type_amd {
CL_DBG_DEBUG_TRAP = 0, //! HW debug
CL_DBG_MAX_TRAP
};
/*! \brief Wave actions used to control the wave execution on the hardware
*
* The wave action enumerations are used to specify the desired
* behavior when calling the wave control function. Overall, there are
* five types of operations that can be specified.
*/
enum cl_dbg_waves_action_amd {
CL_DBG_WAVES_DONT_USE_ZERO = 0, //! NOT USED
CL_DBG_WAVES_HALT = 1, //! halt wave
CL_DBG_WAVES_RESUME = 2, //! resume wave
CL_DBG_WAVES_KILL = 3, //! kill wave
CL_DBG_WAVES_DEBUG = 4, //! debug wave
CL_DBG_WAVES_TRAP = 5, //! trap
CL_DBG_WAVES_MAX
};
/*! \brief Host actions when encountering an exception in the kernel.
*
* The host action enumeration is used to specify the desired host
* response in the event thatn a device kernel exception is encountered.
*/
enum cl_dbg_host_action_amd {
CL_DBG_HOST_IGNORE = 1, //! ignore the kernel exception
CL_DBG_HOST_EXIT = 2, //! exit the host application on a kernel exception
CL_DBG_HOST_NOTIFY = 4 //! report the kernel exception
};
/*! \brief Mode of the wave action when calling the wave control function
*
* The wave mode enumerations are used to specify the desired
* broadcast level when calling the wave control function.
*/
enum cl_dbg_wave_mode_amd {
CL_DBG_WAVEMODE_SINGLE = 0, //! send command to single wave
CL_DBG_WAVEMODE_BROADCAST = 2, //! send command to wave with match VMID
CL_DBG_WAVEMODE_BROADCAST_CU = 3, //! send command to wave with match VMID with specific CU
CL_DBG_WAVEMODE_MAX
};
/*! \brief Enumeration of address watch mode
*
* This enumeration indicates the different modes of address watch.
*/
enum cl_dbg_address_watch_mode_amd {
CL_DBG_ADDR_WATCH_MODE_READ = 0, //! Read operations only
CL_DBG_ADDR_WATCH_MODE_NONREAD = 1, //! Write or Atomic operations only
CL_DBG_ADDR_WATCH_MODE_ATOMIC = 2, //! Atomic Operations only
CL_DBG_ADDR_WATCH_MODE_ALL = 3, //! Read, Write or Atomic operations
CL_DBG_ADDR_WATCH_MODE_MAX //! Number of address watch modes
};
/*! \brief Dispatch exception policy descriptor
*
* The dispatch exception policy descriptor is used to define the
* expected exception policy in the event an exception is encountered
* on the associated dispatch.
*/
typedef struct _cl_dbg_exception_policy_amd {
cl_uint exceptionMask; //! exception mask
cl_dbg_waves_action_amd waveAction; //! wave action
cl_dbg_host_action_amd hostAction; //! host action
cl_dbg_wave_mode_amd waveMode; //! wave mode
} cl_dbg_exception_policy_amd;
/*! \brief Kernel execution mode
*
* This structure is used to control the kernel execution mode. The
* following aspects are included in this structure:
* 1. Regular execution or debug mode (0: regular execution (default),
* 1: debug mode)
* 2. SQ debugger mode on/off
* 3. Disable L1 scalar cache (0: enable (default), 1: disable)
* 4. Disable L1 vector cache (0: enable (default), 1: disable)
* 5. Disable L2 cache (0: enable (default), 1: disable)
* 6. Num of CUs reserved for display (0 (default), 7: max)
*/
typedef struct _cl_dbg_kernel_exec_mode_amd {
union {
struct {
cl_uint monitorMode : 1;
cl_uint gpuSingleStepMode : 1;
cl_uint disableL1Scalar : 1;
cl_uint disableL1Vector : 1;
cl_uint disableL2Cache : 1;
cl_uint reservedCuNum : 3;
cl_uint reserved : 24;
};
cl_uint ui32All;
};
} cl_dbg_kernel_exec_mode_amd;
/*! \brief GPU cache mask
*
* This structure is used to specify the GPU cache to be flushed/invalidated
*/
typedef struct _cl_dbg_gpu_cache_mask_amd {
union {
struct {
cl_uint sqICache : 1; //! instruction cache
cl_uint sqKCache : 1; //! data cache
cl_uint tcL1 : 1; //! tcL1 cache
cl_uint tcL2 : 1; //! tcL2 cache
cl_uint reserved : 28;
};
cl_uint ui32All;
};
} cl_dbg_gpu_cache_mask_amd;
/*! \brief Dispatch Debug Info
*
* This structure is used to store the scratch and global memory descriptors
*/
typedef struct _cl_dispatch_debug_info_amd {
cl_uint scratchMemoryDescriptor[4]; //! Scratch memory descriptors
cl_uint globalMemoryDescriptor[4]; //! Global memory descriptors
} cl_dispatch_debug_info_amd;
/*! \brief AQL Packet Info
*
* This structure is used to store AQL packet informatin for kernel dispatch
*/
typedef struct _cl_aql_packet_info_amd {
cl_uint trapReservedVgprIndex; //! VGPR index reserved for trap
//! value is -1 when kernel was not compiled
//! in debug mode.
cl_uint scratchBufferWaveOffset; //! scratch buffer wave offset
//! value is -1 when kernel was not compiled
//! in debug mode or scratch buffer is not enabled
void* pointerToIsaBuffer; //! Pointer to buffer containing ISA
size_t sizeOfIsaBuffer; //! Size of the ISA buffer
cl_uint numberOfVgprs; //! Number of VGPRs used by the kernel
cl_uint numberOfSgprs; //! Number of SGPRs used by the kernel
size_t sizeOfStaticGroupMemory; //! Static local memory used by the kernel
} cl_aql_packet_info_amd;
/*! \brief Wave address
*
* This structure specifies the wave for the SQ control command
*/
typedef struct _cl_dbg_wave_addr_amd {
cl_uint shaderEngine : 2; //! Shader engine
cl_uint shaderArray : 1; //! Shader array
cl_uint computeUnit : 4; //! Compute unit
cl_uint simd : 2; //! SIMD id
cl_uint wave : 4; //! Wave id
cl_uint vmid : 4; //! VMID
cl_uint reserved : 15;
} cl_dbg_wave_addr_amd;
/*! \brief Pre-dispatch call back function signature
*
* This is the signature of the call back fuction before the kernel
* dispatch. The call back function is to indicate the start of the
* the kernel launch. It is used by the debugger.
*/
typedef void* (*cl_PreDispatchCallBackFunctionAMD)(cl_device_id device, void* ocl_event_handle,
const void* aql_packet, void* acl_binary,
void* user_args);
/*! \brief Post-dispatch call back function signature
*
* This is the signature of the call back fuction after the kernel
* dispatch. The call back function is to indicate the completion of
* the the kernel launch. It is used by the debugger.
*/
typedef void* (*cl_PostDispatchCallBackFunctionAMD)(cl_device_id device, cl_ulong event,
void* user_args);
/*! \brief Set up the dispatch call back function pointers
*
* \param device specifies the device to be used
*
* \param preDispatchFunction is the function to be called before dispatching the kernel
*
* \param postDispatchFunction is the function to be called after kernel execution
*
* \return One of the following values:
* - CL_SUCCESS if the function is executed successfully
* - CL_INVALID_DEVICE if the device is not valid
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
*/
extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgSetCallBackFunctionsAMD(
cl_device_id /* device */, cl_PreDispatchCallBackFunctionAMD /* preDispatchFunction */,
cl_PostDispatchCallBackFunctionAMD /* postDispatchFunction */
) CL_API_SUFFIX__VERSION_2_0;
/*! \brief Set up the arguments of the dispatch call back function
*
* \param device specifies the device to be used
*
* \param preDispatchArgs is the arguments for the pre-dispatch callback function
*
* \param postDispatchArgs is the arguments for the post-dispatch callback function
*
* \return One of the following values:
* - CL_SUCCESS if the function is executed successfully
* - CL_INVALID_DEVICE if the device is not valid
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
*/
extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgSetCallBackArgumentsAMD(cl_device_id /* device */,
void* /* preDispatchArgs */,
void* /* postDispatchArgs */
) CL_API_SUFFIX__VERSION_2_0;
/*! \brief Invalidate all cache on the device.
*
* \param device specifies the device to be used
*
* \param mask is the mask to specify which cache to be flush/invalidate
*
* \return One of the following values:
* - CL_SUCCESS if the function is executed successfully
* - CL_INVALID_DEVICE if the device is not valid
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
*/
extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgFlushCacheAMD(cl_device_id /* device */,
cl_dbg_gpu_cache_mask_amd /* mask */
) CL_API_SUFFIX__VERSION_2_0;
/*! \brief Set up an exception policy in the trap handler object
*
* \param device specifies the device to be used
*
* \param policy specifies the exception policy, which includes the exception mask,
* wave action, host action, wave mode.
*
* \return One of the following values:
* - CL_SUCCESS if the function is executed successfully
* - CL_INVALID_DEVICE if the device is not valid
* - CL_INVALID_VALUE if the policy is not specified (NULL)
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
*/
extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgSetExceptionPolicyAMD(
cl_device_id /* device */, cl_dbg_exception_policy_amd* /* policy */
) CL_API_SUFFIX__VERSION_2_0;
/*! \brief Get the exception policy in the trap handler object
*
* \param device specifies the device to be used
*
* \param policy is a pointer to the memory where the policy is returned
*
* \return One of the following values:
* - CL_SUCCESS if the function is executed successfully
* - CL_INVALID_DEVICE if the device is not valid
* - CL_INVALID_VALUE if the policy storage is not specified
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
*/
extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgGetExceptionPolicyAMD(
cl_device_id /* device */, cl_dbg_exception_policy_amd* /* policy */
) CL_API_SUFFIX__VERSION_2_0;
/*! \brief Set up the kernel execution mode in the trap handler object
*
* \param device specifies the device to be used
*
* \param mode specifies the kernel execution mode, which indicate whether single
* step mode is used, how many CUs are reserved.
*
* \return One of the following values:
* - CL_SUCCESS if the function is executed successfully
* - CL_INVALID_DEVICE if the device is not valid
* - CL_INVALID_VALUE if the mode is not specified, ie, has a NULL value
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
*/
extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgSetKernelExecutionModeAMD(
cl_device_id /* device */, cl_dbg_kernel_exec_mode_amd* /* mode */
) CL_API_SUFFIX__VERSION_2_0;
/*! \brief Get the kernel execution mode in the trap handler object
*
* \param device specifies the device to be used
*
* \param mode is a pointer to the memory where the exectuion mode is returned
*
* \return One of the following values:
* - CL_SUCCESS if the function is executed successfully
* - CL_INVALID_DEVICE if the device is not valid
* - CL_INVALID_VALUE if the mode storage is not specified, ie, has a NULL value
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
*/
extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgGetKernelExecutionModeAMD(
cl_device_id /* device */, cl_dbg_kernel_exec_mode_amd* /* mode */
) CL_API_SUFFIX__VERSION_2_0;
/*! \brief Create a debug event
*
* \param device specifies the device to be used
*
* \param autoReset is the auto reset flag
*
* \param pDebugEvent returns the debug event to be used for exception notification
*
* \param pEventId is the event ID, which is not used at this moment
*
* \return One of the following values:
* - CL_SUCCESS if the function is executed successfully
* - CL_INVALID_DEVICE if the device is not valid
* - CL_INVALID_VALUE if the pDebugEvent value is NULL
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
* - CL_OUT_OF_RESOURCES if fails to create the event
*/
extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgCreateEventAMD(cl_device_id /* device */,
bool /* autoReset */,
cl_dbg_event_amd* /* pDebugEvent */,
cl_uint* /* pEventId */
) CL_API_SUFFIX__VERSION_2_0;
/*! \brief Wait for a debug event to be signaled
*
* \param device specifies the device to be used
*
* \param pDebugEvent is the debug event to be waited for
*
* \param pEventId is the event ID, which is not used at this moment
*
* \param timeOut is the duration for waiting
*
* \return One of the following values:
* - CL_SUCCESS if the event occurs before the timeout
* - CL_INVALID_DEVICE if the device is not valid
* - CL_INVALID_VALUE if the pDebugEvent value is NULL
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
* - CL_EVENT_TIMEOUT_AMD if timeout occurs
*/
extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgWaitEventAMD(cl_device_id /* device */,
cl_dbg_event_amd /* pDebugEvent */,
cl_uint /* pEventId */,
cl_uint /* timeOut */
) CL_API_SUFFIX__VERSION_2_0;
/*! \brief Destroy a debug event
*
* \param device specifies the device to be used
*
* \param pDebugEvent is the debug event to be waited for
*
* \param pEventId is the event ID, which is not used at this moment
*
* \return One of the following values:
* - CL_SUCCESS if the event occurs before the timeout
* - CL_INVALID_DEVICE if the device is not valid
* - CL_INVALID_VALUE if the pDebugEvent value is NULL
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
*/
extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgDestroyEventAMD(cl_device_id /* device */,
cl_dbg_event_amd* /* pDebugEvent */,
cl_uint* /* pEventId */
) CL_API_SUFFIX__VERSION_2_0;
/*! \brief Register the debugger on a device
*
* \param context specifies the context for the debugger
*
* \param device specifies the device to be used
*
* \param pMessageStorge specifies the memory for trap message passing between KMD and OCL runtime
*
* \return One of the following values:
* - CL_SUCCESS if the event occurs before the timeout
* - CL_INVALID_CONTEXT if the context is not valid
* - CL_INVALID_DEVICE if the device is not valid
* - CL_INVALID_VALUE if the pMEssageStorge value is NULL
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
* - CL_OUT_OF_RESOURCES if a host queue cannot be created for the debugger
*/
extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgRegisterDebuggerAMD(
cl_context /* context */, cl_device_id /* device */, volatile void* /* pMessageStorage */
) CL_API_SUFFIX__VERSION_2_0;
/*! \brief Unregister the debugger on a device
*
* \param device specifies the device to be used
*
* \return One of the following values:
* - CL_SUCCESS if the event occurs before the timeout
* - CL_INVALID_DEVICE if the device is not valid
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
*/
extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgUnregisterDebuggerAMD(cl_device_id /* device */
) CL_API_SUFFIX__VERSION_2_0;
/*! \brief Setup the pointer of the acl_binary to be used by the debugger
*
* \param device specifies the device to be used
*
* \param aclBinary specifies the ACL binary to be used
*
* \return One of the following values:
* - CL_SUCCESS if the event occurs before the timeout
* - CL_INVALID_DEVICE if the device is not valid
* - CL_INVALID_VALUE if the aclBinary is not provided
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
*/
extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgSetAclBinaryAMD(cl_device_id /* device */,
void* /* aclBinary */
) CL_API_SUFFIX__VERSION_2_0;
/*! \brief Control the execution of wavefront on the GPU
*
* \param device specifies the device to be used
*
* \param action specifies the wave action - halt, resume, kill, debug
*
* \param mode specifies the wave mode
*
* \param trapID specifies the trap ID, which should be 0x7
*
* \param waveAddress specifies the wave address for the wave control
*
* \return One of the following values:
* - CL_SUCCESS if the event occurs before the timeout
* - CL_INVALID_DEVICE if the device is not valid
* - CL_INVALID_VALUE if the waveMsg is not provided, invalid action or mode value
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
*/
extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgWaveControlAMD(cl_device_id /* device */,
cl_dbg_waves_action_amd /* action */,
cl_dbg_wave_mode_amd /* mode */,
cl_uint /* trapId */,
cl_dbg_wave_addr_amd /* waveAddress */
) CL_API_SUFFIX__VERSION_2_0;
/*! \brief Set watch points on memory address ranges to generate exception events
*
* \param device specifies the device to be used
*
* \param numWatchPoints specifies the number of watch points
*
* \param watchMode is the array of watch mode for the watch points
*
* \param watchAddress is the array of watch address for the watch points
*
* \param watchMask is the array of mask for the watch points
*
* \param watchEvent is the array of event for the watch points
*
* \return One of the following values:
* - CL_SUCCESS if the event occurs before the timeout
* - CL_INVALID_DEVICE if the device is not valid
* - CL_INVALID_VALUE if the number of points <= 0, or other parameters is not specified
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
*/
extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgAddressWatchAMD(
cl_device_id /* device */, cl_uint /* numWatchPoints */,
cl_dbg_address_watch_mode_amd* /* watchMode */, void** /* watchAddress */,
cl_ulong* /* watchMask */, cl_dbg_event_amd* /* watchEvent */
) CL_API_SUFFIX__VERSION_2_0;
/*! \brief Get the packaet information for kernel execution
*
* \param device specifies the device to be used
*
* \param aqlCodeInfo specifies the kernel code and its size
*
* \param packetInfo points to the memory for the packet information to be returned
*
* \return One of the following values:
* - CL_SUCCESS if the event occurs before the timeout
* - CL_INVALID_DEVICE if the device is not valid
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
*/
extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgGetAqlPacketInfoAMD(
cl_device_id /* device */, const void* /* aqlCodeInfo */,
cl_aql_packet_info_amd* /* packetInfo */
) CL_API_SUFFIX__VERSION_2_0;
/*! \brief Get the dispatch debug information
*
* \param device specifies the device to be used
*
* \param debugInfo points to the memory for the debug information to be returned
*
* \return One of the following values:
* - CL_SUCCESS if the event occurs before the timeout
* - CL_INVALID_DEVICE if the device is not valid
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
*/
extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgGetDispatchDebugInfoAMD(
cl_device_id /* device */, cl_dispatch_debug_info_amd* /* debugInfo */
) CL_API_SUFFIX__VERSION_2_0;
/*! \brief Map the video memory for the kernel code to allow host access
*
* \param device specifies the device to be used
*
* \param aqlCodeAddress is the memory points to the returned host memory address for the kernel
* code
*
* \param aqlCodeSize returns the size of the kernel code
*
* \return One of the following values:
* - CL_SUCCESS if the event occurs before the timeout
* - CL_INVALID_DEVICE if the device is not valid
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
*/
extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgMapKernelCodeAMD(cl_device_id /* device */,
void* /* aqlCodeInfo */
) CL_API_SUFFIX__VERSION_2_0;
/*! \brief Unmap the video memory for the kernel code
*
* \param device specifies the device to be used (no needed, just to be consistent)
*
* \param aqlCodeAddress is the memory points to the mapped memory address for the kernel code
*
* \return One of the following values:
* - CL_SUCCESS if the event occurs before the timeout
* - CL_INVALID_DEVICE if the device is not valid
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
*/
extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgUnmapKernelCodeAMD(cl_device_id /* device */,
cl_ulong* /* aqlCodeAddress */
) CL_API_SUFFIX__VERSION_2_0;
/*! \brief Map the shader scratch ring's video memory to allow CPU access
*
* \param device specifies the device to be used
*
* \param scratchRingAddr is the memory points to the returned host memory address for scratch
* ring
*
* \param scratchRingSize returns the size of the scratch ring
*
* \return One of the following values:
* - CL_SUCCESS if the event occurs before the timeout
* - CL_INVALID_DEVICE if the device is not valid
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
*/
extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgMapScratchRingAMD(cl_device_id /* device */,
cl_ulong* /* scratchRingAddr */,
cl_uint* /* scratchRingSize */
) CL_API_SUFFIX__VERSION_2_0;
/*! \brief Unmap the shader scratch ring's video memory
*
* \param device specifies the device to be used (no needed, just to be consistent)
*
* \param scratchRingAddr is the memory points to the mapped memory address for scratch ring
*
* \return One of the following values:
* - CL_SUCCESS if the event occurs before the timeout
* - CL_INVALID_DEVICE if the device is not valid
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
*/
extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgUnmapScratchRingAMD(cl_device_id /* device */,
cl_ulong* /* scratchRingAddr */
) CL_API_SUFFIX__VERSION_2_0;
/*! \brief Get the memory object associated with the kernel parameter
*
* \param device specifies the device to be used
*
* \param paramIdx is the index of of the kernel argument
*
* \param paramMem is pointer of the memory associated with the kernel argument to be returned
*
* \return One of the following values:
* - CL_SUCCESS if the event occurs before the timeout
* - CL_INVALID_DEVICE if the device is not valid
* - CL_INVALID_VALUE if the paramIdx is less than zero, or the paramMem has NULL value
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
* - CL_INVALID_KERNEL_ARGS if it fails to get the memory object for the kernel argument
*/
extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgGetKernelParamMemAMD(cl_device_id /* devicepointer */,
cl_uint /* paramIdx */,
cl_mem* /* paramMem */
) CL_API_SUFFIX__VERSION_2_0;
/*! \brief Set value of a global memory object
*
* \param device specifies the device to be used
*
* \param memObject is the memory object handle to be assigned the value specified in srcMem.
*
* \param offset is offset of the memory object
*
* \param srcMem points to the memory which contains the values to be assigned to the memory
*
* \param size size (in bytes) of the srcMem
*
* \return One of the following values:
* - CL_SUCCESS if the event occurs before the timeout
* - CL_INVALID_DEVICE if the device is not valid
* - CL_INVALID_VALUE if memObj or srcPtr has NULL value, size <= 0 or offset < 0
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
*/
extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgSetGlobalMemoryAMD(cl_device_id /* device */,
cl_mem /* memObject */,
cl_uint /* offset */,
void* /* srcMem */,
cl_uint /* size */
) CL_API_SUFFIX__VERSION_2_0;
/*! \brief Install the trap handler of a given type
*
* \param device specifies the device to be used
*
* \param trapType is the type of trap handler
*
* \param trapHandler is the pointer of trap handler (TBA)
*
* \param trapBuffer is the pointer of trap handler buffer (TMA)
*
* \param trapHandlerSize size (in bytes) of the trap handler
*
* \param trapBufferSize size (in bytes) of the trap handler buffer
*
* \return One of the following values:
* - CL_SUCCESS if the event occurs before the timeout
* - CL_INVALID_DEVICE if the device is not valid
* - CL_INVALID_VALUE if trapHandler is NULL or trapHandlerSize <= 0
* - CL_HWDBG_MANAGER_NOT_AVAILABLE_AMD if there is no HW DEBUG manager
*/
extern CL_API_ENTRY cl_int CL_API_CALL clHwDbgInstallTrapAMD(cl_device_id /* device */,
cl_dbg_trap_type_amd /* trapType */,
cl_mem /* trapHandler */,
cl_mem /* trapBuffer */
) CL_API_SUFFIX__VERSION_2_0;
#ifdef __cplusplus
} /*extern "C"*/
#endif /*__cplusplus*/
#endif /*__CL_DEBUGGER_AMD_H*/
projects/hip/amdocl/cl_icd_amd.h
+739
View File
@@ -0,0 +1,739 @@
/*******************************************************************************
* Copyright (c) 2008-2010 The Khronos Group Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and/or associated documentation files (the
* "Materials"), to deal in the Materials without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Materials, and to
* permit persons to whom the Materials are furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Materials.
*
* THE MATERIALS ARE 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 AUTHORS 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
* MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
******************************************************************************/
#ifndef __OPENCL_CL_ICD_H
#define __OPENCL_CL_ICD_H
#include <CL/cl.h>
#include <CL/cl_gl.h>
#define cl_khr_icd 1
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
typedef cl_int(CL_API_CALL* clGetPlatformIDs_fn)(
cl_uint /* num_entries */, cl_platform_id* /* platforms */,
cl_uint* /* num_platforms */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clGetPlatformInfo_fn)(
cl_platform_id /* platform */, cl_platform_info /* param_name */, size_t /* param_value_size */,
void* /* param_value */, size_t* /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clGetDeviceIDs_fn)(
cl_platform_id /* platform */, cl_device_type /* device_type */, cl_uint /* num_entries */,
cl_device_id* /* devices */, cl_uint* /* num_devices */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clGetDeviceInfo_fn)(
cl_device_id /* device */, cl_device_info /* param_name */, size_t /* param_value_size */,
void* /* param_value */, size_t* /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_context(CL_API_CALL* clCreateContext_fn)(
const cl_context_properties* /* properties */, cl_uint /* num_devices */,
const cl_device_id* /* devices */,
void(CL_CALLBACK* /* pfn_notify */)(const char*, const void*, size_t, void*),
void* /* user_data */, cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_context(CL_API_CALL* clCreateContextFromType_fn)(
const cl_context_properties* /* properties */, cl_device_type /* device_type */,
void(CL_CALLBACK* /* pfn_notify*/)(const char*, const void*, size_t, void*),
void* /* user_data */, cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clRetainContext_fn)(cl_context /* context */)
CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clReleaseContext_fn)(cl_context /* context */)
CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clGetContextInfo_fn)(
cl_context /* context */, cl_context_info /* param_name */, size_t /* param_value_size */,
void* /* param_value */, size_t* /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_command_queue(CL_API_CALL* clCreateCommandQueue_fn)(
cl_context /* context */, cl_device_id /* device */,
cl_command_queue_properties /* properties */,
cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clRetainCommandQueue_fn)(cl_command_queue /* command_queue */)
CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clReleaseCommandQueue_fn)(cl_command_queue /* command_queue */)
CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clGetCommandQueueInfo_fn)(
cl_command_queue /* command_queue */, cl_command_queue_info /* param_name */,
size_t /* param_value_size */, void* /* param_value */,
size_t* /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clSetCommandQueueProperty_fn)(
cl_command_queue /* command_queue */, cl_command_queue_properties /* properties */,
cl_bool /* enable */,
cl_command_queue_properties* /* old_properties */) /*CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED*/;
typedef cl_mem(CL_API_CALL* clCreateBuffer_fn)(
cl_context /* context */, cl_mem_flags /* flags */, size_t /* size */, void* /* host_ptr */,
cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_mem(CL_API_CALL* clCreateSubBuffer_fn)(
cl_mem /* buffer */, cl_mem_flags /* flags */, cl_buffer_create_type /* buffer_create_type */,
const void* /* buffer_create_info */, cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_1;
typedef cl_mem(CL_API_CALL* clCreateImage2D_fn)(
cl_context /* context */, cl_mem_flags /* flags */, const cl_image_format* /* image_format */,
size_t /* image_width */, size_t /* image_height */, size_t /* image_row_pitch */,
void* /* host_ptr */, cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_mem(CL_API_CALL* clCreateImage3D_fn)(
cl_context /* context */, cl_mem_flags /* flags */, const cl_image_format* /* image_format */,
size_t /* image_width */, size_t /* image_height */, size_t /* image_depth */,
size_t /* image_row_pitch */, size_t /* image_slice_pitch */, void* /* host_ptr */,
cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clRetainMemObject_fn)(cl_mem /* memobj */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clReleaseMemObject_fn)(cl_mem /* memobj */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clGetSupportedImageFormats_fn)(
cl_context /* context */, cl_mem_flags /* flags */, cl_mem_object_type /* image_type */,
cl_uint /* num_entries */, cl_image_format* /* image_formats */,
cl_uint* /* num_image_formats */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clGetMemObjectInfo_fn)(
cl_mem /* memobj */, cl_mem_info /* param_name */, size_t /* param_value_size */,
void* /* param_value */, size_t* /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clGetImageInfo_fn)(
cl_mem /* image */, cl_image_info /* param_name */, size_t /* param_value_size */,
void* /* param_value */, size_t* /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clSetMemObjectDestructorCallback_fn)(
cl_mem /* memobj */,
void(CL_CALLBACK* /*pfn_notify*/)(cl_mem /* memobj */, void* /*user_data*/),
void* /*user_data */) CL_API_SUFFIX__VERSION_1_1;
/* Sampler APIs */
typedef cl_sampler(CL_API_CALL* clCreateSampler_fn)(
cl_context /* context */, cl_bool /* normalized_coords */,
cl_addressing_mode /* addressing_mode */, cl_filter_mode /* filter_mode */,
cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clRetainSampler_fn)(cl_sampler /* sampler */)
CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clReleaseSampler_fn)(cl_sampler /* sampler */)
CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clGetSamplerInfo_fn)(
cl_sampler /* sampler */, cl_sampler_info /* param_name */, size_t /* param_value_size */,
void* /* param_value */, size_t* /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
/* Program Object APIs */
typedef cl_program(CL_API_CALL* clCreateProgramWithSource_fn)(
cl_context /* context */, cl_uint /* count */, const char** /* strings */,
const size_t* /* lengths */, cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_program CL_API_CALL
clCreateProgramWithIL(cl_context /* context */,
const void * /* strings */, size_t /* lengths */,
cl_int * /* errcode_ret */) CL_EXT_SUFFIX__VERSION_2_0;
typedef cl_program(CL_API_CALL* clCreateProgramWithILKHR_fn)(
cl_context /* context */, const void* /* il */, size_t /* length */,
cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_2;
typedef cl_program(CL_API_CALL* clCreateProgramWithBinary_fn)(
cl_context /* context */, cl_uint /* num_devices */, const cl_device_id* /* device_list */,
const size_t* /* lengths */, const unsigned char** /* binaries */, cl_int* /* binary_status */,
cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clRetainProgram_fn)(cl_program /* program */)
CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clReleaseProgram_fn)(cl_program /* program */)
CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clBuildProgram_fn)(
cl_program /* program */, cl_uint /* num_devices */, const cl_device_id* /* device_list */,
const char* /* options */,
void(CL_CALLBACK* /* pfn_notify */)(cl_program /* program */, void* /* user_data */),
void* /* user_data */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clUnloadCompiler_fn)(void) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clGetProgramInfo_fn)(
cl_program /* program */, cl_program_info /* param_name */, size_t /* param_value_size */,
void* /* param_value */, size_t* /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clGetProgramBuildInfo_fn)(
cl_program /* program */, cl_device_id /* device */, cl_program_build_info /* param_name */,
size_t /* param_value_size */, void* /* param_value */,
size_t* /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
/* Kernel Object APIs */
typedef cl_kernel(CL_API_CALL* clCreateKernel_fn)(
cl_program /* program */, const char* /* kernel_name */,
cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clCreateKernelsInProgram_fn)(
cl_program /* program */, cl_uint /* num_kernels */, cl_kernel* /* kernels */,
cl_uint* /* num_kernels_ret */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clRetainKernel_fn)(cl_kernel /* kernel */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clReleaseKernel_fn)(cl_kernel /* kernel */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clSetKernelArg_fn)(cl_kernel /* kernel */, cl_uint /* arg_index */,
size_t /* arg_size */, const void* /* arg_value */)
CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clGetKernelInfo_fn)(
cl_kernel /* kernel */, cl_kernel_info /* param_name */, size_t /* param_value_size */,
void* /* param_value */, size_t* /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clGetKernelWorkGroupInfo_fn)(
cl_kernel /* kernel */, cl_device_id /* device */, cl_kernel_work_group_info /* param_name */,
size_t /* param_value_size */, void* /* param_value */,
size_t* /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
/* Event Object APIs */
typedef cl_int(CL_API_CALL* clWaitForEvents_fn)(
cl_uint /* num_events */, const cl_event* /* event_list */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clGetEventInfo_fn)(
cl_event /* event */, cl_event_info /* param_name */, size_t /* param_value_size */,
void* /* param_value */, size_t* /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_event(CL_API_CALL* clCreateUserEvent_fn)(
cl_context /* context */, cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_1;
typedef cl_int(CL_API_CALL* clRetainEvent_fn)(cl_event /* event */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clReleaseEvent_fn)(cl_event /* event */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clSetUserEventStatus_fn)(
cl_event /* event */, cl_int /* execution_status */) CL_API_SUFFIX__VERSION_1_1;
typedef cl_int(CL_API_CALL* clSetEventCallback_fn)(
cl_event /* event */, cl_int /* command_exec_callback_type */,
void(CL_CALLBACK* /* pfn_notify */)(cl_event, cl_int, void*),
void* /* user_data */) CL_API_SUFFIX__VERSION_1_1;
/* Profiling APIs */
typedef cl_int(CL_API_CALL* clGetEventProfilingInfo_fn)(
cl_event /* event */, cl_profiling_info /* param_name */, size_t /* param_value_size */,
void* /* param_value */, size_t* /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
/* Flush and Finish APIs */
typedef cl_int(CL_API_CALL* clFlush_fn)(cl_command_queue /* command_queue */)
CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clFinish_fn)(cl_command_queue /* command_queue */)
CL_API_SUFFIX__VERSION_1_0;
/* Enqueued Commands APIs */
typedef cl_int(CL_API_CALL* clEnqueueReadBuffer_fn)(
cl_command_queue /* command_queue */, cl_mem /* buffer */, cl_bool /* blocking_read */,
size_t /* offset */, size_t /* cb */, void* /* ptr */, cl_uint /* num_events_in_wait_list */,
const cl_event* /* event_wait_list */, cl_event* /* event */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clEnqueueReadBufferRect_fn)(
cl_command_queue /* command_queue */, cl_mem /* buffer */, cl_bool /* blocking_read */,
const size_t* /* buffer_offset */, const size_t* /* host_offset */, const size_t* /* region */,
size_t /* buffer_row_pitch */, size_t /* buffer_slice_pitch */, size_t /* host_row_pitch */,
size_t /* host_slice_pitch */, void* /* ptr */, cl_uint /* num_events_in_wait_list */,
const cl_event* /* event_wait_list */, cl_event* /* event */) CL_API_SUFFIX__VERSION_1_1;
typedef cl_int(CL_API_CALL* clEnqueueWriteBuffer_fn)(
cl_command_queue /* command_queue */, cl_mem /* buffer */, cl_bool /* blocking_write */,
size_t /* offset */, size_t /* cb */, const void* /* ptr */,
cl_uint /* num_events_in_wait_list */, const cl_event* /* event_wait_list */,
cl_event* /* event */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clEnqueueWriteBufferRect_fn)(
cl_command_queue /* command_queue */, cl_mem /* buffer */, cl_bool /* blocking_read */,
const size_t* /* buffer_offset */, const size_t* /* host_offset */, const size_t* /* region */,
size_t /* buffer_row_pitch */, size_t /* buffer_slice_pitch */, size_t /* host_row_pitch */,
size_t /* host_slice_pitch */, const void* /* ptr */, cl_uint /* num_events_in_wait_list */,
const cl_event* /* event_wait_list */, cl_event* /* event */) CL_API_SUFFIX__VERSION_1_1;
typedef cl_int(CL_API_CALL* clEnqueueCopyBuffer_fn)(
cl_command_queue /* command_queue */, cl_mem /* src_buffer */, cl_mem /* dst_buffer */,
size_t /* src_offset */, size_t /* dst_offset */, size_t /* cb */,
cl_uint /* num_events_in_wait_list */, const cl_event* /* event_wait_list */,
cl_event* /* event */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clEnqueueCopyBufferRect_fn)(
cl_command_queue /* command_queue */, cl_mem /* src_buffer */, cl_mem /* dst_buffer */,
const size_t* /* src_origin */, const size_t* /* dst_origin */, const size_t* /* region */,
size_t /* src_row_pitch */, size_t /* src_slice_pitch */, size_t /* dst_row_pitch */,
size_t /* dst_slice_pitch */, cl_uint /* num_events_in_wait_list */,
const cl_event* /* event_wait_list */, cl_event* /* event */) CL_API_SUFFIX__VERSION_1_1;
typedef cl_int(CL_API_CALL* clEnqueueReadImage_fn)(
cl_command_queue /* command_queue */, cl_mem /* image */, cl_bool /* blocking_read */,
const size_t* /* origin[3] */, const size_t* /* region[3] */, size_t /* row_pitch */,
size_t /* slice_pitch */, void* /* ptr */, cl_uint /* num_events_in_wait_list */,
const cl_event* /* event_wait_list */, cl_event* /* event */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clEnqueueWriteImage_fn)(
cl_command_queue /* command_queue */, cl_mem /* image */, cl_bool /* blocking_write */,
const size_t* /* origin[3] */, const size_t* /* region[3] */, size_t /* input_row_pitch */,
size_t /* input_slice_pitch */, const void* /* ptr */, cl_uint /* num_events_in_wait_list */,
const cl_event* /* event_wait_list */, cl_event* /* event */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clEnqueueCopyImage_fn)(
cl_command_queue /* command_queue */, cl_mem /* src_image */, cl_mem /* dst_image */,
const size_t* /* src_origin[3] */, const size_t* /* dst_origin[3] */,
const size_t* /* region[3] */, cl_uint /* num_events_in_wait_list */,
const cl_event* /* event_wait_list */, cl_event* /* event */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clEnqueueCopyImageToBuffer_fn)(
cl_command_queue /* command_queue */, cl_mem /* src_image */, cl_mem /* dst_buffer */,
const size_t* /* src_origin[3] */, const size_t* /* region[3] */, size_t /* dst_offset */,
cl_uint /* num_events_in_wait_list */, const cl_event* /* event_wait_list */,
cl_event* /* event */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clEnqueueCopyBufferToImage_fn)(
cl_command_queue /* command_queue */, cl_mem /* src_buffer */, cl_mem /* dst_image */,
size_t /* src_offset */, const size_t* /* dst_origin[3] */, const size_t* /* region[3] */,
cl_uint /* num_events_in_wait_list */, const cl_event* /* event_wait_list */,
cl_event* /* event */) CL_API_SUFFIX__VERSION_1_0;
typedef void*(CL_API_CALL* clEnqueueMapBuffer_fn)(
cl_command_queue /* command_queue */, cl_mem /* buffer */, cl_bool /* blocking_map */,
cl_map_flags /* map_flags */, size_t /* offset */, size_t /* cb */,
cl_uint /* num_events_in_wait_list */, const cl_event* /* event_wait_list */,
cl_event* /* event */, cl_int* /* errcode_ret */)CL_API_SUFFIX__VERSION_1_0;
typedef void*(CL_API_CALL* clEnqueueMapImage_fn)(
cl_command_queue /* command_queue */, cl_mem /* image */, cl_bool /* blocking_map */,
cl_map_flags /* map_flags */, const size_t* /* origin[3] */, const size_t* /* region[3] */,
size_t* /* image_row_pitch */, size_t* /* image_slice_pitch */,
cl_uint /* num_events_in_wait_list */, const cl_event* /* event_wait_list */,
cl_event* /* event */, cl_int* /* errcode_ret */)CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clEnqueueUnmapMemObject_fn)(
cl_command_queue /* command_queue */, cl_mem /* memobj */, void* /* mapped_ptr */,
cl_uint /* num_events_in_wait_list */, const cl_event* /* event_wait_list */,
cl_event* /* event */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clEnqueueNDRangeKernel_fn)(
cl_command_queue /* command_queue */, cl_kernel /* kernel */, cl_uint /* work_dim */,
const size_t* /* global_work_offset */, const size_t* /* global_work_size */,
const size_t* /* local_work_size */, cl_uint /* num_events_in_wait_list */,
const cl_event* /* event_wait_list */, cl_event* /* event */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clEnqueueTask_fn)(cl_command_queue /* command_queue */,
cl_kernel /* kernel */,
cl_uint /* num_events_in_wait_list */,
const cl_event* /* event_wait_list */,
cl_event* /* event */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clEnqueueNativeKernel_fn)(
cl_command_queue /* command_queue */, void(CL_CALLBACK* user_func)(void*), void* /* args */,
size_t /* cb_args */, cl_uint /* num_mem_objects */, const cl_mem* /* mem_list */,
const void** /* args_mem_loc */, cl_uint /* num_events_in_wait_list */,
const cl_event* /* event_wait_list */, cl_event* /* event */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clEnqueueMarker_fn)(cl_command_queue /* command_queue */,
cl_event* /* event */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clEnqueueWaitForEvents_fn)(
cl_command_queue /* command_queue */, cl_uint /* num_events */,
const cl_event* /* event_list */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clEnqueueBarrier_fn)(cl_command_queue /* command_queue */)
CL_API_SUFFIX__VERSION_1_0;
typedef void*(CL_API_CALL* clGetExtensionFunctionAddress_fn)(const char* /* func_name */)
CL_API_SUFFIX__VERSION_1_0;
typedef cl_mem(CL_API_CALL* clCreateFromGLBuffer_fn)(
cl_context /* context */, cl_mem_flags /* flags */, cl_GLuint /* bufobj */,
int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_mem(CL_API_CALL* clCreateFromGLTexture2D_fn)(
cl_context /* context */, cl_mem_flags /* flags */, cl_GLenum /* target */,
cl_GLint /* miplevel */, cl_GLuint /* texture */,
cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_mem(CL_API_CALL* clCreateFromGLTexture3D_fn)(
cl_context /* context */, cl_mem_flags /* flags */, cl_GLenum /* target */,
cl_GLint /* miplevel */, cl_GLuint /* texture */,
cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_mem(CL_API_CALL* clCreateFromGLRenderbuffer_fn)(
cl_context /* context */, cl_mem_flags /* flags */, cl_GLuint /* renderbuffer */,
cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clGetGLObjectInfo_fn)(
cl_mem /* memobj */, cl_gl_object_type* /* gl_object_type */,
cl_GLuint* /* gl_object_name */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clGetGLTextureInfo_fn)(
cl_mem /* memobj */, cl_gl_texture_info /* param_name */, size_t /* param_value_size */,
void* /* param_value */, size_t* /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_event(CL_API_CALL* clCreateEventFromGLsyncKHR_fn)(
cl_context /* context */, cl_GLsync /* cl_GLsync */,
cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_1;
typedef cl_int(CL_API_CALL* clEnqueueAcquireGLObjects_fn)(
cl_command_queue /* command_queue */, cl_uint /* num_objects */,
const cl_mem* /* mem_objects */, cl_uint /* num_events_in_wait_list */,
const cl_event* /* event_wait_list */, cl_event* /* event */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clEnqueueReleaseGLObjects_fn)(
cl_command_queue /* command_queue */, cl_uint /* num_objects */,
const cl_mem* /* mem_objects */, cl_uint /* num_events_in_wait_list */,
const cl_event* /* event_wait_list */, cl_event* /* event */) CL_API_SUFFIX__VERSION_1_0;
typedef cl_int(CL_API_CALL* clCreateSubDevices_fn)(
cl_device_id /* in_device */, const cl_device_partition_property* /* properties */,
cl_uint /* num_entries */, cl_device_id* /* out_devices */,
cl_uint* /* num_devices */) CL_API_SUFFIX__VERSION_1_2;
typedef cl_int(CL_API_CALL* clRetainDevice_fn)(cl_device_id /* device */)
CL_API_SUFFIX__VERSION_1_2;
typedef cl_int(CL_API_CALL* clReleaseDevice_fn)(cl_device_id /* device */)
CL_API_SUFFIX__VERSION_1_2;
typedef cl_mem(CL_API_CALL* clCreateImage_fn)(cl_context /* context */, cl_mem_flags /* flags */,
const cl_image_format* /* image_format*/,
const cl_image_desc* /* image_desc*/,
void* /* host_ptr */,
cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_2;
typedef cl_program(CL_API_CALL* clCreateProgramWithBuiltInKernels_fn)(
cl_context /* context */, cl_uint /* num_devices */, const cl_device_id* /* device_list */,
const char* /* kernel_names */, cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_2;
typedef cl_int(CL_API_CALL* clCompileProgram_fn)(
cl_program /* program */, cl_uint /* num_devices */, const cl_device_id* /* device_list */,
const char* /* options */, cl_uint /* num_input_headers */,
const cl_program* /* input_headers */, const char** /* header_include_names */,
void(CL_CALLBACK* pfn_notify)(cl_program program, void* user_data),
void* /* user_data */) CL_API_SUFFIX__VERSION_1_2;
typedef cl_program(CL_API_CALL* clLinkProgram_fn)(
cl_context /* context */, cl_uint /* num_devices */, const cl_device_id* /* device_list */,
const char* /* options */, cl_uint /* num_input_programs */,
const cl_program* /* input_programs */,
void(CL_CALLBACK* pfn_notify)(cl_program program, void* user_data), void* /* user_data */,
cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_2;
typedef cl_int(CL_API_CALL* clUnloadPlatformCompiler_fn)(cl_platform_id /* platform */)
CL_API_SUFFIX__VERSION_1_2;
typedef cl_int(CL_API_CALL* clGetKernelArgInfo_fn)(
cl_kernel /* kernel */, cl_uint /* arg_indx */, cl_kernel_arg_info /* param_name */,
size_t /* param_value_size */, void* /* param_value */,
size_t* /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_2;
typedef cl_int(CL_API_CALL* clEnqueueFillBuffer_fn)(
cl_command_queue /* command_queue */, cl_mem /* buffer */, const void* /* pattern */,
size_t /* pattern_size */, size_t /* offset */, size_t /* size */,
cl_uint /* num_events_in_wait_list */, const cl_event* /* event_wait_list */,
cl_event* /* event */) CL_API_SUFFIX__VERSION_1_2;
typedef cl_int(CL_API_CALL* clEnqueueFillImage_fn)(
cl_command_queue /* command_queue */, cl_mem /* image */, const void* /* fill_color */,
const size_t* /* origin */, const size_t* /* region */, cl_uint /* num_events_in_wait_list */,
const cl_event* /* event_wait_list */, cl_event* /* event */) CL_API_SUFFIX__VERSION_1_2;
typedef cl_int(CL_API_CALL* clEnqueueMigrateMemObjects_fn)(
cl_command_queue /* command_queue */, cl_uint /* num_mem_objects */,
const cl_mem* /* mem_objects */, cl_mem_migration_flags /* flags */,
cl_uint /* num_events_in_wait_list */, const cl_event* /* event_wait_list */,
cl_event* /* event */) CL_API_SUFFIX__VERSION_1_2;
typedef cl_int(CL_API_CALL* clEnqueueMarkerWithWaitList_fn)(
cl_command_queue /* command_queue */, cl_uint /* num_events_in_wait_list */,
const cl_event* /* event_wait_list */, cl_event* /* event */) CL_API_SUFFIX__VERSION_1_2;
typedef cl_int(CL_API_CALL* clEnqueueBarrierWithWaitList_fn)(
cl_command_queue /* command_queue */, cl_uint /* num_events_in_wait_list */,
const cl_event* /* event_wait_list */, cl_event* /* event */) CL_API_SUFFIX__VERSION_1_2;
typedef void*(CL_API_CALL* clGetExtensionFunctionAddressForPlatform_fn)(
cl_platform_id /* platform */, const char* /* funcname */)CL_API_SUFFIX__VERSION_1_2;
typedef cl_mem(CL_API_CALL* clCreateFromGLTexture_fn)(
cl_context /* context */, cl_mem_flags /* flags */, cl_GLenum /* texture_target */,
cl_GLint /* miplevel */, cl_GLuint /* texture */,
cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_2;
typedef cl_command_queue(CL_API_CALL* clCreateCommandQueueWithProperties_fn)(
cl_context /* context */, cl_device_id /* device */,
const cl_queue_properties* /* properties */,
cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_2_0;
typedef cl_sampler(CL_API_CALL* clCreateSamplerWithProperties_fn)(
cl_context /* context */, const cl_sampler_properties* /* properties */,
cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_2_0;
typedef void*(CL_API_CALL* clSVMAlloc_fn)(cl_context /* context */, cl_svm_mem_flags /* flags */,
size_t /* size */,
cl_uint /* alignment */)CL_API_SUFFIX__VERSION_2_0;
typedef void(CL_API_CALL* clSVMFree_fn)(cl_context /* context */,
void* /* svm_pointer */) CL_API_SUFFIX__VERSION_2_0;
typedef cl_int(CL_API_CALL* clSetKernelArgSVMPointer_fn)(
cl_kernel /* kernel */, cl_uint /* arg_index */,
const void* /* arg_value */) CL_API_SUFFIX__VERSION_2_0;
typedef cl_int(CL_API_CALL* clSetKernelExecInfo_fn)(
cl_kernel /* kernel */, cl_kernel_exec_info /* param_name */, size_t /* param_value_size */,
const void* /* param_value */) CL_API_SUFFIX__VERSION_2_0;
typedef cl_int(CL_API_CALL* clEnqueueSVMFree_fn)(
cl_command_queue /* command_queue */, cl_uint /* num_svm_pointers */,
void* [] /* svm_pointers */,
void(CL_CALLBACK* /* pfn_free_func */)(cl_command_queue /* queue */,
cl_uint /* num_svm_pointers */,
void* [] /* svm_pointers */, void* /* user_data */),
void* /* user_data */, cl_uint /* num_events_in_wait_list */,
const cl_event* /* event_wait_list */, cl_event* /* event */) CL_API_SUFFIX__VERSION_2_0;
typedef cl_int(CL_API_CALL* clEnqueueSVMMemcpy_fn)(
cl_command_queue /* command_queue */, cl_bool /* blocking_copy */, void* /* dst_ptr */,
const void* /* src_ptr */, size_t /* size */, cl_uint /* num_events_in_wait_list */,
const cl_event* /* event_wait_list */, cl_event* /* event */) CL_API_SUFFIX__VERSION_2_0;
typedef cl_int(CL_API_CALL* clEnqueueSVMMemFill_fn)(
cl_command_queue /* command_queue */, void* /* svm_ptr */, const void* /* pattern */,
size_t /* pattern_size */, size_t /* size */, cl_uint /* num_events_in_wait_list */,
const cl_event* /* event_wait_list */, cl_event* /* event */) CL_API_SUFFIX__VERSION_2_0;
typedef cl_int(CL_API_CALL* clEnqueueSVMMap_fn)(
cl_command_queue /* command_queue */, cl_bool /* blocking_map */, cl_map_flags /* flags */,
void* /* svm_ptr */, size_t /* size */, cl_uint /* num_events_in_wait_list */,
const cl_event* /* event_wait_list */, cl_event* /* event */) CL_API_SUFFIX__VERSION_2_0;
typedef cl_int(CL_API_CALL* clEnqueueSVMUnmap_fn)(cl_command_queue /* command_queue */,
void* /* svm_ptr */,
cl_uint /* num_events_in_wait_list */,
const cl_event* /* event_wait_list */,
cl_event* /* event */) CL_API_SUFFIX__VERSION_2_0;
typedef cl_mem(CL_API_CALL* clCreatePipe_fn)(cl_context /* context */, cl_mem_flags /* flags */,
cl_uint /* pipe_packet_size */,
cl_uint /* pipe_max_packets */,
const cl_pipe_properties* /* properties */,
cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_2_0;
typedef cl_int(CL_API_CALL* clGetPipeInfo_fn)(
cl_mem /* pipe */, cl_pipe_info /* param_name */, size_t /* param_value_size */,
void* /* param_value */, size_t* /* param_value_size_ret */) CL_API_SUFFIX__VERSION_2_0;
typedef cl_int(CL_API_CALL* clGetKernelSubGroupInfoKHR_fn)(
cl_kernel /* kernel */, cl_device_id /* device */, cl_kernel_sub_group_info /* param_name */,
size_t /* input_value_size */, const void* /* input_value */, size_t /* param_value_size */,
void* /* param_value */, size_t* /* param_value_size_ret */) CL_API_SUFFIX__VERSION_2_0;
typedef cl_int(CL_API_CALL* clSetDefaultDeviceCommandQueue_fn)(
cl_context /* context */, cl_device_id /* device */,
cl_command_queue /* command_queue */) CL_API_SUFFIX__VERSION_2_1;
typedef cl_kernel(CL_API_CALL* clCloneKernel_fn)(
cl_kernel /* source_kernel */, cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_2_1;
typedef cl_int (CL_API_CALL* clEnqueueSVMMigrateMem_fn)(
cl_command_queue /* command_queue */, cl_uint /* num_svm_pointers */,
const void ** /* svm_pointers */, const size_t * /* sizes */,
cl_mem_migration_flags /* flags */, cl_uint /* num_events_in_wait_list */,
const cl_event * /* event_wait_list */, cl_event * /* event */) CL_API_SUFFIX__VERSION_2_1;
typedef cl_int (CL_API_CALL* clGetDeviceAndHostTimer_fn)(
cl_device_id /* device */, cl_ulong * /* device_timestamp */,
cl_ulong * /* host_timestamp */) CL_API_SUFFIX__VERSION_2_1;
typedef cl_int (CL_API_CALL* clGetHostTimer_fn)(
cl_device_id /* device */, cl_ulong * /* host_timestamp */) CL_API_SUFFIX__VERSION_2_1;
typedef cl_int (CL_API_CALL* clSetProgramSpecializationConstant_fn)(
cl_program /* program */, cl_uint /* spec_id */, size_t /* spec_size */,
const void* /* spec_value */) CL_API_SUFFIX__VERSION_2_2;
typedef cl_int (CL_API_CALL* clSetProgramReleaseCallback_fn)(
cl_program /* program */,
void (CL_CALLBACK * /* pfn_notify */)(cl_program program, void * user_data),
void * /* user_data */) CL_API_SUFFIX__VERSION_2_2;
typedef struct _cl_icd_dispatch_table {
/* OpenCL 1.0 */
clGetPlatformIDs_fn GetPlatformIDs;
clGetPlatformInfo_fn GetPlatformInfo;
clGetDeviceIDs_fn GetDeviceIDs;
clGetDeviceInfo_fn GetDeviceInfo;
clCreateContext_fn CreateContext;
clCreateContextFromType_fn CreateContextFromType;
clRetainContext_fn RetainContext;
clReleaseContext_fn ReleaseContext;
clGetContextInfo_fn GetContextInfo;
clCreateCommandQueue_fn CreateCommandQueue;
clRetainCommandQueue_fn RetainCommandQueue;
clReleaseCommandQueue_fn ReleaseCommandQueue;
clGetCommandQueueInfo_fn GetCommandQueueInfo;
clSetCommandQueueProperty_fn SetCommandQueueProperty;
clCreateBuffer_fn CreateBuffer;
clCreateImage2D_fn CreateImage2D;
clCreateImage3D_fn CreateImage3D;
clRetainMemObject_fn RetainMemObject;
clReleaseMemObject_fn ReleaseMemObject;
clGetSupportedImageFormats_fn GetSupportedImageFormats;
clGetMemObjectInfo_fn GetMemObjectInfo;
clGetImageInfo_fn GetImageInfo;
clCreateSampler_fn CreateSampler;
clRetainSampler_fn RetainSampler;
clReleaseSampler_fn ReleaseSampler;
clGetSamplerInfo_fn GetSamplerInfo;
clCreateProgramWithSource_fn CreateProgramWithSource;
clCreateProgramWithBinary_fn CreateProgramWithBinary;
clRetainProgram_fn RetainProgram;
clReleaseProgram_fn ReleaseProgram;
clBuildProgram_fn BuildProgram;
clUnloadCompiler_fn UnloadCompiler;
clGetProgramInfo_fn GetProgramInfo;
clGetProgramBuildInfo_fn GetProgramBuildInfo;
clCreateKernel_fn CreateKernel;
clCreateKernelsInProgram_fn CreateKernelsInProgram;
clRetainKernel_fn RetainKernel;
clReleaseKernel_fn ReleaseKernel;
clSetKernelArg_fn SetKernelArg;
clGetKernelInfo_fn GetKernelInfo;
clGetKernelWorkGroupInfo_fn GetKernelWorkGroupInfo;
clWaitForEvents_fn WaitForEvents;
clGetEventInfo_fn GetEventInfo;
clRetainEvent_fn RetainEvent;
clReleaseEvent_fn ReleaseEvent;
clGetEventProfilingInfo_fn GetEventProfilingInfo;
clFlush_fn Flush;
clFinish_fn Finish;
clEnqueueReadBuffer_fn EnqueueReadBuffer;
clEnqueueWriteBuffer_fn EnqueueWriteBuffer;
clEnqueueCopyBuffer_fn EnqueueCopyBuffer;
clEnqueueReadImage_fn EnqueueReadImage;
clEnqueueWriteImage_fn EnqueueWriteImage;
clEnqueueCopyImage_fn EnqueueCopyImage;
clEnqueueCopyImageToBuffer_fn EnqueueCopyImageToBuffer;
clEnqueueCopyBufferToImage_fn EnqueueCopyBufferToImage;
clEnqueueMapBuffer_fn EnqueueMapBuffer;
clEnqueueMapImage_fn EnqueueMapImage;
clEnqueueUnmapMemObject_fn EnqueueUnmapMemObject;
clEnqueueNDRangeKernel_fn EnqueueNDRangeKernel;
clEnqueueTask_fn EnqueueTask;
clEnqueueNativeKernel_fn EnqueueNativeKernel;
clEnqueueMarker_fn EnqueueMarker;
clEnqueueWaitForEvents_fn EnqueueWaitForEvents;
clEnqueueBarrier_fn EnqueueBarrier;
clGetExtensionFunctionAddress_fn GetExtensionFunctionAddress;
clCreateFromGLBuffer_fn CreateFromGLBuffer;
clCreateFromGLTexture2D_fn CreateFromGLTexture2D;
clCreateFromGLTexture3D_fn CreateFromGLTexture3D;
clCreateFromGLRenderbuffer_fn CreateFromGLRenderbuffer;
clGetGLObjectInfo_fn GetGLObjectInfo;
clGetGLTextureInfo_fn GetGLTextureInfo;
clEnqueueAcquireGLObjects_fn EnqueueAcquireGLObjects;
clEnqueueReleaseGLObjects_fn EnqueueReleaseGLObjects;
clGetGLContextInfoKHR_fn GetGLContextInfoKHR;
void* _reservedForD3D10KHR[6];
/* OpenCL 1.1 */
clSetEventCallback_fn SetEventCallback;
clCreateSubBuffer_fn CreateSubBuffer;
clSetMemObjectDestructorCallback_fn SetMemObjectDestructorCallback;
clCreateUserEvent_fn CreateUserEvent;
clSetUserEventStatus_fn SetUserEventStatus;
clEnqueueReadBufferRect_fn EnqueueReadBufferRect;
clEnqueueWriteBufferRect_fn EnqueueWriteBufferRect;
clEnqueueCopyBufferRect_fn EnqueueCopyBufferRect;
void* _reservedForDeviceFissionEXT[3];
clCreateEventFromGLsyncKHR_fn CreateEventFromGLsyncKHR;
/* OpenCL 1.2 */
clCreateSubDevices_fn CreateSubDevices;
clRetainDevice_fn RetainDevice;
clReleaseDevice_fn ReleaseDevice;
clCreateImage_fn CreateImage;
clCreateProgramWithBuiltInKernels_fn CreateProgramWithBuiltInKernels;
clCompileProgram_fn CompileProgram;
clLinkProgram_fn LinkProgram;
clUnloadPlatformCompiler_fn UnloadPlatformCompiler;
clGetKernelArgInfo_fn GetKernelArgInfo;
clEnqueueFillBuffer_fn EnqueueFillBuffer;
clEnqueueFillImage_fn EnqueueFillImage;
clEnqueueMigrateMemObjects_fn EnqueueMigrateMemObjects;
clEnqueueMarkerWithWaitList_fn EnqueueMarkerWithWaitList;
clEnqueueBarrierWithWaitList_fn EnqueueBarrierWithWaitList;
clGetExtensionFunctionAddressForPlatform_fn GetExtensionFunctionAddressForPlatform;
clCreateFromGLTexture_fn CreateFromGLTexture;
/* cl_khr_d3d11_sharing, cl_khr_dx9_media_sharing */
void* _reservedForD3DExtensions[10];
/* cl_khr_egl_image, cl_khr_egl_event */
void* _reservedForEGLExtensions[4];
/* OpenCL 2.0 */
clCreateCommandQueueWithProperties_fn CreateCommandQueueWithProperties;
clCreatePipe_fn CreatePipe;
clGetPipeInfo_fn GetPipeInfo;
clSVMAlloc_fn SVMAlloc;
clSVMFree_fn SVMFree;
clEnqueueSVMFree_fn EnqueueSVMFree;
clEnqueueSVMMemcpy_fn EnqueueSVMMemcpy;
clEnqueueSVMMemFill_fn EnqueueSVMMemFill;
clEnqueueSVMMap_fn EnqueueSVMMap;
clEnqueueSVMUnmap_fn EnqueueSVMUnmap;
clCreateSamplerWithProperties_fn CreateSamplerWithProperties;
clSetKernelArgSVMPointer_fn SetKernelArgSVMPointer;
clSetKernelExecInfo_fn SetKernelExecInfo;
/* cl_khr_sub_groups */
clGetKernelSubGroupInfoKHR_fn GetKernelSubGroupInfoKHR;
/* OpenCL 2.1 */
clCloneKernel_fn CloneKernel;
clCreateProgramWithILKHR_fn CreateProgramWithILKHR;
clEnqueueSVMMigrateMem_fn EnqueueSVMMigrateMem;
clGetDeviceAndHostTimer_fn GetDeviceAndHostTimer;
clGetHostTimer_fn GetHostTimer;
clGetKernelSubGroupInfoKHR_fn GetKernelSubGroupInfo;
clSetDefaultDeviceCommandQueue_fn SetDefaultDeviceCommandQueue;
/* OpenCL 2.2 */
clSetProgramReleaseCallback_fn SetProgramReleaseCallback;
clSetProgramSpecializationConstant_fn SetProgramSpecializationConstant;
} cl_icd_dispatch_table;
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __OPENCL_CL_ICD_H */
projects/hip/amdocl/cl_kernel.h
+149
View File
@@ -0,0 +1,149 @@
/*
* Copyright (c) 2012 Advanced Micro Devices, Inc. All rights reserved.
*/
#ifndef CL_KERNEL_H_
#define CL_KERNEL_H_
struct clk_builtins_t;
// This must be a multiple of sizeof(cl_ulong16)
#define __CPU_SCRATCH_SIZE 128
#define CLK_PRIVATE_MEMORY_SIZE (16 * 1024)
struct clk_thread_info_block_t {
// Warning! The size of this struct needs to be a multiple
// of 16 when compiling 64 bit
struct clk_builtins_t const* builtins;
void* local_mem_base;
void* local_scratch;
const void* table_base;
size_t pad;
uint work_dim;
size_t global_offset[4]; /*dim0,dim1,dim2,invalid(dim<0||dim>2)*/
size_t global_size[4]; /*dim0,dim1,dim2,invalid(dim<0||dim>2)*/
size_t enqueued_local_size[4];
size_t local_size[4]; /*dim0,dim1,dim2,invalid(dim<0||dim>2)*/
size_t local_id[4]; /*dim0,dim1,dim2,invalid(dim<0||dim>2)*/
size_t group_id[4]; /*dim0,dim1,dim2,invalid(dim<0||dim>2)*/
};
typedef enum clk_value_type_t {
T_VOID,
T_CHAR,
T_SHORT,
T_INT,
T_LONG,
T_FLOAT,
T_DOUBLE,
T_POINTER,
T_CHAR2,
T_CHAR3,
T_CHAR4,
T_CHAR8,
T_CHAR16,
T_SHORT2,
T_SHORT3,
T_SHORT4,
T_SHORT8,
T_SHORT16,
T_INT2,
T_INT3,
T_INT4,
T_INT8,
T_INT16,
T_LONG2,
T_LONG3,
T_LONG4,
T_LONG8,
T_LONG16,
T_FLOAT2,
T_FLOAT3,
T_FLOAT4,
T_FLOAT8,
T_FLOAT16,
T_DOUBLE2,
T_DOUBLE3,
T_DOUBLE4,
T_DOUBLE8,
T_DOUBLE16,
T_SAMPLER,
T_SEMA,
T_STRUCT,
T_QUEUE,
T_PAD
} clk_value_type_t;
typedef enum clk_address_space_t {
A_PRIVATE,
A_LOCAL,
A_CONSTANT,
A_GLOBAL,
A_REGION
} clk_address_space_t;
// kernel arg access qualifier and type qualifier
typedef enum clk_arg_qualifier_t {
Q_NONE = 0,
// for image type only, access qualifier
Q_READ = 1,
Q_WRITE = 2,
// for pointer type only
Q_CONST = 4, // pointee
Q_RESTRICT = 8,
Q_VOLATILE = 16, // pointee
Q_PIPE = 32 // pipe
} clk_arg_qualifier_t;
#pragma pack(push, 4)
struct clk_parameter_descriptor_t {
clk_value_type_t type;
clk_address_space_t space;
uint qualifier;
const char* name;
};
#pragma pack(pop)
//#define CLK_LOCAL_MEM_FENCE (1 << 0)
//#define CLK_GLOBAL_MEM_FENCE (1 << 1)
struct clk_builtins_t {
/* Synchronization functions */
void (*barrier_ptr)(cl_mem_fence_flags flags);
/* AMD Only builtins: FIXME_lmoriche (extension) */
void* reserved;
int (*printf_ptr)(const char* format, ...);
};
enum clk_natures_t { KN_HAS_BARRIER = 1 << 0, KN_WG_LEVEL = 1 << 1 };
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 4200)
#endif
#if !defined(__OPENCL_VERSION__) || __OPENCL_VERSION__ >= 200
typedef struct clk_pipe_t {
size_t read_idx;
size_t write_idx;
size_t end_idx;
char padding[128 - 3 * sizeof(size_t)];
char packets[];
} clk_pipe_t;
#endif
#if defined(_MSC_VER)
#pragma warning(pop)
#endif
#endif /*CL_KERNEL_H_*/
projects/hip/amdocl/cl_profile_amd.h
+173
View File
@@ -0,0 +1,173 @@
//
// Copyright (c) 2009 Advanced Micro Devices, Inc. All rights reserved.
//
#ifndef __CL_PROFILE_AMD_H
#define __CL_PROFILE_AMD_H
#include "CL/cl_platform.h"
#ifdef __cplusplus
extern "C" {
#endif /*__cplusplus*/
typedef struct _cl_perfcounter_amd* cl_perfcounter_amd;
typedef cl_ulong cl_perfcounter_property;
typedef cl_uint cl_perfcounter_info;
/* cl_perfcounter_info */
enum PerfcounterInfo {
CL_PERFCOUNTER_NONE = 0x0,
CL_PERFCOUNTER_REFERENCE_COUNT = 0x1,
CL_PERFCOUNTER_DATA = 0x2,
CL_PERFCOUNTER_GPU_BLOCK_INDEX = 0x3,
CL_PERFCOUNTER_GPU_COUNTER_INDEX = 0x4,
CL_PERFCOUNTER_GPU_EVENT_INDEX = 0x5,
CL_PERFCOUNTER_LAST
};
/*********************************
* Set device clock mode data
*********************************/
enum cl_DeviceClockMode_AMD {
CL_DEVICE_CLOCK_MODE_DEFAULT_AMD = 0x0, /*Device clocks and other power settings are restored to default*/
CL_DEVICE_CLOCK_MODE_QUERY_AMD = 0x1, /*Queries the current device clock ratios. Leaves the clock mode of the device unchanged*/
CL_DEVICE_CLOCK_MODE_PROFILING_AMD = 0x2, /*Scale down from peak ratio*/
CL_DEVICE_CLOCK_MODE_MINIMUMMEMORY_AMD = 0x3, /* Memory clock is set to the lowest available level*/
CL_DEVICE_CLOCK_MODE_MINIMUMENGINE_AMD = 0x4, /*Engine clock is set to the lowest available level*/
CL_DEVICE_CLOCK_MODE_PEAK_AMD = 0x5, /*Clocks set to maximum when possible. Fan set to maximum.*/
CL_DEVICE_CLOCK_MODE_QUERYPROFILING_AMD = 0x6, /*Queries the profiling device clock ratios. Leaves the clock mode of the device unchanged*/
CL_DEVICE_CLOCK_MODE_QUERYPEAK_AMD = 0x7, /*Queries the peak device clock ratios.Leaves the clock mode of the device unchanged*/
CL_DEVICE_CLOCK_MODE_COUNT_AMD = 0x8, /*Maxmium count of device clock mode*/
};
typedef struct _cl_set_device_clock_mode_input_amd
{
/* specify the clock mode for AMD GPU device*/
cl_DeviceClockMode_AMD clock_mode;
} cl_set_device_clock_mode_input_amd;
typedef struct _cl_set_device_clock_mode_output_amd
{
/*Ratio of current mem clock to peak clock as obtained from DeviceProperties::maxGpuClock*/
cl_float memory_clock_ratio_to_peak;
/*Ratio of current gpu core clock to peak clock as obtained from DeviceProperties::maxGpuClock*/
cl_float engine_clock_ratio_to_peak;
} cl_set_device_clock_mode_output_amd;
/*! \brief Creates a new HW performance counter
* for the specified OpenCL context.
*
* \param device must be a valid OpenCL device.
*
* \param properties the list of properties of the hardware counter
*
* \param errcode_ret A non zero value if OpenCL failed to create PerfCounter
* - CL_SUCCESS if the function is executed successfully.
* - CL_INVALID_CONTEXT if the specified context is invalid.
* - CL_OUT_OF_RESOURCES if we couldn't create the object
*
* \return the created perfcounter object
*/
extern CL_API_ENTRY cl_perfcounter_amd CL_API_CALL clCreatePerfCounterAMD(
cl_device_id /* device */, cl_perfcounter_property* /* properties */, cl_int* /* errcode_ret */
) CL_API_SUFFIX__VERSION_1_0;
/*! \brief Destroy a performance counter object.
*
* \param perf_counter the perfcounter object for release
*
* \return A non zero value if OpenCL failed to release PerfCounter
* - CL_SUCCESS if the function is executed successfully.
* - CL_INVALID_OPERATION if we failed to release the object
*/
extern CL_API_ENTRY cl_int CL_API_CALL clReleasePerfCounterAMD(cl_perfcounter_amd /* perf_counter */
) CL_API_SUFFIX__VERSION_1_0;
/*! \brief Increments the perfcounter object reference count.
*
* \param perf_counter the perfcounter object for retain
*
* \return A non zero value if OpenCL failed to retain PerfCounter
* - CL_SUCCESS if the function is executed successfully.
* - CL_INVALID_OPERATION if we failed to release the object
*/
extern CL_API_ENTRY cl_int CL_API_CALL clRetainPerfCounterAMD(cl_perfcounter_amd /* perf_counter */
) CL_API_SUFFIX__VERSION_1_0;
/*! \brief Enqueues the begin command for the specified counters.
*
* \param command_queue must be a valid OpenCL command queue.
*
* \param num_perf_counters the number of perfcounter objects in the array.
*
* \param perf_counters specifies an array of perfcounter objects.
*
* \return A non zero value if OpenCL failed to release PerfCounter
* - CL_SUCCESS if the function is executed successfully.
* - CL_INVALID_OPERATION if we failed to enqueue the begin operation
*/
extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueBeginPerfCounterAMD(
cl_command_queue /* command_queue */, cl_uint /* num_perf_counters */,
cl_perfcounter_amd* /* perf_counters */, cl_uint /* num_events_in_wait_list */,
const cl_event* /* event_wait_list */, cl_event* /* event */
) CL_API_SUFFIX__VERSION_1_0;
/*! \brief Enqueues the end command for the specified counters.
*
* \param command_queue must be a valid OpenCL command queue.
*
* \param num_perf_counters the number of perfcounter objects in the array.
*
* \param perf_counters specifies an array of perfcounter objects.
*
* \param event the event object associated with the end operation.
*
* \return A non zero value if OpenCL failed to release PerfCounter
* - CL_SUCCESS if the function is executed successfully.
* - CL_INVALID_OPERATION if we failed to enqueue the end operation
*/
extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueEndPerfCounterAMD(
cl_command_queue /* command_queue */, cl_uint /* num_perf_counters */,
cl_perfcounter_amd* /* perf_counters */, cl_uint /* num_events_in_wait_list */,
const cl_event* /* event_wait_list */, cl_event* /* event */
) CL_API_SUFFIX__VERSION_1_0;
/*! \brief Retrieves the results from the counter objects.
*
* \param perf_counter specifies a perfcounter objects for query.
*
* \param param_name specifies the information to query.
*
* \param param_value is a pointer to memory where the appropriate result
* being queried is returned. If \a param_value is NULL, it is ignored.
*
* \param param_value_size is used to specify the size in bytes of memory
* pointed to by \a param_value. This size must be >= size of return type.
*
* \param param_value_size_ret returns the actual size in bytes of data copied
* to \a param_value. If \a param_value_size_ret is NULL, it is ignored.
*
* \param values must be a valid pointer to an array of 64-bit values
* and the array size must be equal to num_perf_counters.
*
* \return
* - CL_SUCCESS if the function is executed successfully.
* - CL_PROFILING_INFO_NOT_AVAILABLE if event isn't finished.
* - CL_INVALID_OPERATION if we failed to get the data
*/
extern CL_API_ENTRY cl_int CL_API_CALL clGetPerfCounterInfoAMD(
cl_perfcounter_amd /* perf_counter */, cl_perfcounter_info /* param_name */,
size_t /* param_value_size */, void* /* param_value */, size_t* /* param_value_size_ret */
) CL_API_SUFFIX__VERSION_1_0;
extern CL_API_ENTRY cl_int CL_API_CALL clSetDeviceClockModeAMD(
cl_device_id /* device*/, cl_set_device_clock_mode_input_amd /* Clock_Mode_Input */,
cl_set_device_clock_mode_output_amd* /* Clock_Mode_Output */
) CL_API_SUFFIX__VERSION_1_0;
#ifdef __cplusplus
} /*extern "C"*/
#endif /*__cplusplus*/
#endif /*__CL_PROFILE_AMD_H*/
projects/hip/amdocl/cl_thread_trace_amd.h
+347
View File
@@ -0,0 +1,347 @@
//
// Copyright (c) 2012 Advanced Micro Devices, Inc. All rights reserved.
//
#ifndef __CL_THREAD_TRACE_AMD_H
#define __CL_THREAD_TRACE_AMD_H
#include "CL/cl_platform.h"
#ifdef __cplusplus
extern "C" {
#endif /*__cplusplus*/
typedef struct _cl_threadtrace_amd* cl_threadtrace_amd;
typedef cl_uint cl_thread_trace_param;
typedef cl_uint cl_threadtrace_info;
/* cl_command_type */
#define CL_COMMAND_THREAD_TRACE_MEM 0x4500
#define CL_COMMAND_THREAD_TRACE 0x4501
/* cl_threadtrace_command_name_amd enumeration */
typedef enum _cl_threadtrace_command_name_amd {
CL_THREAD_TRACE_BEGIN_COMMAND,
CL_THREAD_TRACE_END_COMMAND,
CL_THREAD_TRACE_PAUSE_COMMAND,
CL_THREAD_TRACE_RESUME_COMMAND
} cl_threadtrace_command_name_amd;
// Thread trace parameters
enum ThreadTraceParameter {
CL_THREAD_TRACE_PARAM_TOKEN_MASK,
CL_THREAD_TRACE_PARAM_REG_MASK,
CL_THREAD_TRACE_PARAM_COMPUTE_UNIT_TARGET,
CL_THREAD_TRACE_PARAM_SHADER_ARRAY_TARGET,
CL_THREAD_TRACE_PARAM_SIMD_MASK,
CL_THREAD_TRACE_PARAM_VM_ID_MASK,
CL_THREAD_TRACE_PARAM_RANDOM_SEED,
CL_THREAD_TRACE_PARAM_CAPTURE_MODE,
CL_THREAD_TRACE_PARAM_INSTRUCTION_MASK,
CL_THREAD_TRACE_PARAM_USER_DATA,
CL_THREAD_TRACE_PARAM_IS_WRAPPED
};
// CL_THREAD_TRACE_PARAM_TOKEN_MASK data selects for SI
enum CL_THREAD_TRACE_TOKEN_MASK {
// Time passed
CL_THREAD_TRACE_TOKEN_MASK_TIME_SI = 0x00000001,
// Resync the timestamp
CL_THREAD_TRACE_TOKEN_MASK_TIMESTAMP_SI = 0x00000002,
// A register write has occurred
CL_THREAD_TRACE_TOKEN_MASK_REG_SI = 0x00000004,
// A wavefront has started
CL_THREAD_TRACE_TOKEN_MASK_WAVE_START_SI = 0x00000008,
// Output space has been allocated for color/Z [Should be used for cl-gl]
CL_THREAD_TRACE_TOKEN_MASK_WAVE_PS_ALLOC_SI = 0x00000010,
// Output space has been allocated for vertex position [Should be used for cl-gl]
CL_THREAD_TRACE_TOKEN_MASK_WAVE_VS_ALLOC_SI = 0x00000020,
// Wavefront completion
CL_THREAD_TRACE_TOKEN_MASK_WAVE_END_SI = 0x00000040,
// An event has reached the top of a shader stage. In-order with WAVE_START
CL_THREAD_TRACE_TOKEN_MASK_EVENT_SI = 0x00000080,
// An event has reached the top of a compute shader stage. In-order with WAVE_START
CL_THREAD_TRACE_TOKEN_MASK_EVENT_CS_SI = 0x00000100,
// An event has reached the top of a shader stage for the second GFX pipe. In-order with
// WAVE_START.
//[Should be used for cl-gl]
CL_THREAD_TRACE_TOKEN_MASK_EVENT_GFX_SI = 0x00000200,
// The kernel has executed an instruction
CL_THREAD_TRACE_TOKEN_MASK_INST_SI = 0x00000400,
// The kernel has explicitly written the PC value
CL_THREAD_TRACE_TOKEN_MASK_INST_PC_SI = 0x00000800,
// The kernel has written user data into the thread trace buffer
CL_THREAD_TRACE_TOKEN_MASK_INST_USERDATA_SI = 0x00001000,
// Provides information about instruction scheduling
CL_THREAD_TRACE_TOKEN_MASK_ISSUE_SI = 0x00002000,
// The performance counter delta has been updated
CL_THREAD_TRACE_TOKEN_MASK_PERF_SI = 0x00004000,
// A miscellaneous event has been sent
CL_THREAD_TRACE_TOKEN_MASK_MISC_SI = 0x00008000,
// All possible tokens
CL_THREAD_TRACE_TOKEN_MASK_ALL_SI = 0x0000ffff,
};
// CL_THREAD_TRACE_PARAM_REG_MASK data selects
enum CL_THREAD_TRACE_REG_MASK {
// Event initiator
CL_THREAD_TRACE_REG_MASK_EVENT_SI = 0x00000001,
// Draw initiator [Should be used for cl-gl]
CL_THREAD_TRACE_REG_MASK_DRAW_SI = 0x00000002,
// Dispatch initiator
CL_THREAD_TRACE_REG_MASK_DISPATCH_SI = 0x00000004,
// User data from host
CL_THREAD_TRACE_REG_MASK_USERDATA_SI = 0x00000008,
// GFXDEC register (8-state) [Should be used for cl-gl]
CL_THREAD_TRACE_REG_MASK_GFXDEC_SI = 0x00000020,
// SHDEC register (many state)
CL_THREAD_TRACE_REG_MASK_SHDEC_SI = 0x00000040,
// Other registers
CL_THREAD_TRACE_REG_MASK_OTHER_SI = 0x00000080,
// All possible registers types
CL_THREAD_TRACE_REG_MASK_ALL_SI = 0x000000ff,
};
// CL_THREAD_TRACE_PARAM_VM_ID_MASK data selects
enum CL_THREAD_TRACE_VM_ID_MASK {
// Capture only data from the VM_ID used to write {SQTT}_BASE
CL_THREAD_TRACE_VM_ID_MASK_SINGLE = 0,
// Capture all data from all VM_IDs
CL_THREAD_TRACE_VM_ID_MASK_ALL = 1,
// Capture all data but only get target (a.k.a. detail) data from VM_ID used to write {SQTT}_BASE
CL_THREAD_TRACE_VM_ID_MASK_SINGLE_DETAIL = 2
};
// CL_THREAD_TRACE_PARAM_CAPTURE_MODE data
enum CL_THREAD_TRACE_CAPTURE_MODE {
// Capture all data in the thread trace buffer
CL_THREAD_TRACE_CAPTURE_ALL = 0,
// Capture only data between THREAD_TRACE_START and THREAD_TRACE_STOP events
CL_THREAD_TRACE_CAPTURE_SELECT = 1,
// Capture data between THREAD_TRACE_START and THREAD_TRACE_/STOP events,
// and global/reference data at all times
CL_THREAD_TRACE_CAPTURE_SELECT_DETAIL = 2
};
// CL_THREAD_TRACE_PARAM_INSTRUCTION_MASK data selects
enum CL_THREAD_TRACE_INSTRUCTION_MASK {
// Generate {SQTT}_TOKEN_INST tokens for all instructions
CL_THREAD_TRACE_INST_MASK_ALL,
// Generate {SQTT}_TOKEN_INST tokens for stalled instructions only
CL_THREAD_TRACE_INST_MASK_STALLED,
// Generate {SQTT}_TOKEN_INST messages for stalled and other (no op/wait/set prio/etc)
// instructions
CL_THREAD_TRACE_INST_MASK_STALLED_AND_IMMEDIATE,
// Generate {SQTT}_TOKEN_INST messages for immediate instructions only only [ Should be used only
// for CI]
CL_THREAD_TRACE_INST_MASK_IMMEDIATE_CI,
};
enum ThreadTraceInfo {
CL_THREAD_TRACE_SE,
CL_THREAD_TRACE_BUFFERS_FILLED,
CL_THREAD_TRACE_BUFFERS_SIZE
};
/*! \brief Creates a new cl_threadtrace_amd object
*
* \param device must be a valid OpenCL device.
*
* \param errcode_ret A non zero value if OpenCL failed to create threadTrace
* -CL_INVALID_DEVICE if devices contains an invalid device.
* -CL_DEVICE_NOT_AVAILABLE if a device is currently not available even
* though the device was returned by clGetDeviceIDs.
* -CL_OUT_OF_RESOURCES if there is a failure to allocate resources required by the
* OpenCL implementation on the device.
* -CL_OUT_OF_HOST_MEMORY if there is a failure to allocate resources required by the
OpenCL implementation on the host.
*
* \return the created threadTrace object
*/
extern CL_API_ENTRY cl_threadtrace_amd CL_API_CALL clCreateThreadTraceAMD(
cl_device_id /* device */, cl_int* /* errcode_ret */
) CL_API_SUFFIX__VERSION_1_0;
/*! \brief Destroys a cl_threadtrace_amd object.
*
* \param threadTrace the cl_threadtrace_amd object for release
*
* \return A non zero value if OpenCL failed to release threadTrace
* -CL_INVALID_VALUE if the thread_trace is not a valid OpenCL thread trace object
(cl_threadtrace_amd) .
* -CL_OUT_OF_RESOURCES if there is a failure to allocate resources required by the
* OpenCL implementation on the device.
* -CL_OUT_OF_HOST_MEMORY if there is a failure to allocate resources required by the
OpenCL implementation on the host.
*/
extern CL_API_ENTRY cl_int CL_API_CALL clReleaseThreadTraceAMD(cl_threadtrace_amd /* threadTrace */
) CL_API_SUFFIX__VERSION_1_0;
/*! \brief Increments the cl_threadtrace_amd object reference count.
*
* \param threadTrace the cl_threadtrace_amd object for retain
*
* \return A non zero value if OpenCL failed to retain threadTrace
* -CL_INVALID_VALUE if the thread_trace is not a valid thread trace object (cl_threadtrace_amd) .
* -CL_OUT_OF_RESOURCES if there is a failure to allocate resources required by the
OpenCL implementation on the device.
* -CL_OUT_OF_HOST_MEMORY if there is a failure to allocate resources required by the
OpenCL implementation on the host.
*/
extern CL_API_ENTRY cl_int CL_API_CALL clRetainThreadTraceAMD(cl_threadtrace_amd /* threadTrace */
) CL_API_SUFFIX__VERSION_1_0;
/*! \brief Sets the cl_threadtrace_amd object configuration parameter.
*
* \param thread_trace the cl_threadtrace_amd object to set configuration parameter
*
* \param config_param the cl_thread_trace_param
*
* \param param_value corresponding to configParam
*
* \return A non zero value if OpenCL failed to set threadTrace buffer parameter
* - CL_INVALID_VALUE if the thread_trace is invalid thread trace object.
* - CL_INVALID_VALUE if the invalid config_param or param_value enum values , are used.
* - CL_INVALID_EVENT_WAIT_LIST if event_wait_list is NULL and num_events_in_wait_list > 0, or
event_wait_list is not NULL and num_events_in_wait_list is 0,
* - or if event objects in event_wait_list are not valid events.
* - CL_OUT_OF_RESOURCES if there is a failure to allocate resources required by the OpenCL
implementation on the device.
* - CL_OUT_OF_HOST_MEMORY if there is a failure to allocate resources required by the
OpenCL implementation on the host.
*/
extern CL_API_ENTRY cl_int CL_API_CALL clSetThreadTraceParamAMD(
cl_threadtrace_amd /*thread_trace*/, cl_thread_trace_param /*config_param*/,
cl_uint /*param_value*/
) CL_API_SUFFIX__VERSION_1_0;
/* \brief Enqueues the binding command to bind cl_threadtrace_amd to cl_mem object for trace
* recording..
*
* \param command_queue must be a valid OpenCL command queue.
*
* \param thread_trace specifies the cl_threadtrace_amd object.
*
* \param mem_objects the cl_mem objects for trace recording
*
* \param mem_objects_num the number of cl_mem objects in the mem_objects
*
* \param buffer_size the size of each cl_mem object from mem_objects
*
* \param event_wait_list specify [is a pointer to] events that need to
* complete before this particular command can be executed.
* If \a event_wait_list is NULL, then this particular command does not wait
* on any event to complete. If \a event_wait_list is NULL,
* \a num_events_in_wait_list must be 0. If \a event_wait_list is not NULL,
* the list of events pointed to by \a event_wait_list must be valid and
* \a num_events_in_wait_list must be greater than 0. The events specified in
* \a event_wait_list act as synchronization points.
*
* \param num_events_in_wait_list specify the number of events in
* \a event_wait_list. It must be 0 if \a event_wait_list is NULL. It must be
* greater than 0 if \a event_wait_list is not NULL.
*
* \param event returns an event object that identifies this particular
* command and can be used to query or queue a wait for this particular
* command to complete. \a event can be NULL in which case it will not be
* possible for the application to query the status of this command or queue a
* wait for this command to complete.
* \return A non zero value if OpenCL failed to set threadTrace buffer parameter
* - CL_INVALID_COMMAND_QUEUE if command_queue is not a valid command-queue.
* - CL_INVALID_CONTEXT if the context associated with command_queue and events in event_wait_list
* are not the same.
* - CL_INVALID_VALUE if the thread_trace is invalid thread trace object.
* - CL_INVALID_VALUE if the buffer_size is negative or zero.
* - CL_INVALID_VALUE if the sub_buffers_num I less than 1.
* - CL_INVALID_OPERATION if the mem_objects_num is not equal to the number of Shader Engines of
* the [GPU] device.
* - CL_INVALID_MEM_OBJECT if one on memory objects in the mem_objects array is not a valid memory
* object or memory_objects is NULL.
* - CL_MEM_OBJECT_ALLOCATION_FAILURE if there is a failure to allocate memory for the data store
* associated from the memory objects of the mem_objects array.
* - CL_INVALID_EVENT_WAIT_LIST if event_wait_list is NULL and num_events_in_wait_list > 0, or
* event_wait_list is not NULL and num_events_in_wait_list is 0, or if event objects in
* event_wait_list are not valid events.
* - CL_OUT_OF_RESOURCES if there is a failure to allocate resources required by the OpenCL
* implementation on the device.
* - CL_OUT_OF_HOST_MEMORY if there is a failure to allocate resources required by the
* OpenCL implementation on the host.
*/
extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueBindThreadTraceBufferAMD(
cl_command_queue command_queue, cl_threadtrace_amd /*thread_trace*/, cl_mem* /*mem_objects*/,
cl_uint /*mem_objects_num*/, cl_uint /*buffer_size*/, cl_uint /*num_events_in_wait_list*/,
const cl_event* /*event_wait_list*/, cl_event* /*event*/
) CL_API_SUFFIX__VERSION_1_0;
/*! \brief Get specific information about the OpenCL Thread Trace.
*
* \param thread_trace_info_param is an enum that identifies the Thread Trace information being
* queried.
*
* \param param_value is a pointer to memory location where appropriate values
* for a given \a threadTrace_info_param will be returned. If \a param_value is NULL,
* it is ignored.
*
* \param param_value_size specifies the size in bytes of memory pointed to by
* \a param_value. This size in bytes must be >= size of return type.
*
* \param param_value_size_ret returns the actual size in bytes of data being
* queried by param_value. If \a param_value_size_ret is NULL, it is ignored.
*
* \return One of the following values:
* CL_INVALID_OPERATION if cl_threadtrace_amd object is not valid
* - CL_INVALID_VALUE if \a param_name is not one of the supported
* values or if size in bytes specified by \a param_value_size is < size of
* return type and \a param_value is not a NULL value.
* CL_OUT_OF_HOST_MEMORY if there is a failure to allocate resources required by the
* OpenCL implementation on the host.
* CL_SUCCESS if the function is executed successfully.
*/
extern CL_API_ENTRY cl_int CL_API_CALL clGetThreadTraceInfoAMD(
cl_threadtrace_amd /* thread_trace */, cl_threadtrace_info /*thread_trace_info_param*/,
size_t /*param_value_size*/, void* /*param_value*/, size_t* /*param_value_size_ret*/
) CL_API_SUFFIX__VERSION_1_0;
/*! \brief Enqueues the thread trace command for the specified thread trace object.
*
* \param command_queue must be a valid OpenCL command queue.
*
* \param threadTraces specifies an array of cl_threadtrace_amd objects.
*
* \return A non zero value if OpenCL failed to release threadTrace
* - CL_INVALID_COMMAND_QUEUE if command_queue is not a valid command-queue.
* - CL_INVALID_CONTEXT if the context associated with command_queue and events in event_wait_list
* are not the same.
* - CL_INVALID_VALUE if the thread_trace is invalid thread trace object .
* - CL_INVALID_VALUE if the invalid command name enum value , not described in the
* cl_threadtrace_command_name_amd, is used.
* - CL_INVALID_OPERATION if the command enqueue failed. It can happen in the following cases:
* o BEGIN_COMMAND is queued for thread trace object for which memory object/s was/were not
* bound..
* o END_COMMAND is queued for thread trace object, for which BEGIN_COMMAND was not queued.
* o PAUSE_COMMAND is queued for thread trace object, for which BEGIN_COMMAND was not
* queued.
* o RESUME_COMMAND is queued for thread trace object, for which PAUSE_COMMAND was not
* queued.
* - CL_INVALID_EVENT_WAIT_LIST if event_wait_list is NULL and num_events_in_wait_list > 0, or
* event_wait_list is not NULL and num_events_in_wait_list is 0, or if event objects in
* event_wait_list are not valid events.
* - CL_OUT_OF_RESOURCES if there is a failure to allocate resources required by the OpenCL
* implementation on the device.
* - CL_OUT_OF_HOST_MEMORY if there is a failure to allocate resources required by the OpenCL
* implementation on the host.
*/
extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueThreadTraceCommandAMD(
cl_command_queue /*command_queue*/, cl_threadtrace_amd /*thread_trace*/,
cl_threadtrace_command_name_amd /*command_name*/, cl_uint /*num_events_in_wait_list*/,
const cl_event* /*event_wait_list*/, cl_event* /*event*/
) CL_API_SUFFIX__VERSION_1_0;
#ifdef __cplusplus
} /*extern "C"*/
#endif /*__cplusplus*/
#endif /*__CL_THREAD_TRACE_AMD_H*/
projects/hip/amdocl/gl_functions.hpp
+47
View File
@@ -0,0 +1,47 @@
//
// Copyright 2010 Advanced Micro Devices, Inc. All rights reserved.
//
GLPREFIX(GLubyte*, glGetString, (GLenum name))
GLPREFIX(void, glBindBuffer, (GLenum target, GLuint buffer))
//GLPREFIX(void, glBindFramebufferEXT, (GLenum target, GLuint framebuffer))
GLPREFIX(void, glBindRenderbuffer, (GLenum target, GLuint renderbuffer))
GLPREFIX(void, glBindTexture, (GLenum target, GLuint texture))
GLPREFIX(void, glBufferData, (GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage))
GLPREFIX(GLenum, glCheckFramebufferStatusEXT, (GLenum target))
GLPREFIX(void, glDeleteBuffers, (GLsizei n, const GLuint* buffers))
GLPREFIX(void, glDrawPixels, (GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels))
//GLPREFIX(void, glFramebufferRenderbufferEXT, (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer))
GLPREFIX(void, glGenBuffers, (GLsizei n, GLuint* buffers))
//GLPREFIX(void, glGenFramebuffersEXT, (GLsizei n, GLuint* framebuffers))
//10
GLPREFIX(void, glGetBufferParameteriv, (GLenum target, GLenum pname, GLint* params))
GLPREFIX(GLenum, glGetError, (void))
GLPREFIX(void, glFinish, (void))
GLPREFIX(void, glFlush, (void))
GLPREFIX(GLenum, glClientWaitSync, (GLsync sync, GLbitfield flags, GLuint64 timeout))
GLPREFIX(void, glGetIntegerv, (GLenum pname, GLint *params))
GLPREFIX(void, glGetRenderbufferParameterivEXT, (GLenum target, GLenum pname, GLint* params))
//GLPREFIX(GLubyte*, glGetString, (GLenum name))
GLPREFIX(void, glGetTexImage, (GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels))
GLPREFIX(void, glGetTexLevelParameteriv, (GLenum target, GLint level, GLenum pname, GLint *params))
GLPREFIX(void, glGetTexParameteriv, (GLenum target, GLenum pname, GLint *params))
GLPREFIX(GLboolean, glIsBuffer, (GLuint buffer))
GLPREFIX(GLboolean, glIsRenderbufferEXT, (GLuint renderbuffer))
GLPREFIX(GLboolean, glIsTexture, (GLuint texture))
//20
GLPREFIX(GLvoid*, glMapBuffer, (GLenum target, GLenum access))
GLPREFIX(void, glReadPixels, (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels))
GLPREFIX(void, glTexImage2D, (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels))
GLPREFIX(void, glTexImage3D, (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels))
GLPREFIX(GLboolean, glUnmapBuffer, (GLenum target))
#undef GLPREFIX
projects/hip/amdocl/icd/loader/icd_dispatch.h
+1511
View File
File diff suppressed because it is too large Load Diff
projects/hip/cmake/FindROCR.cmake
+16
View File
@@ -0,0 +1,16 @@
# Try to find ROCR (Radeon Open Compute Runtime)
#
# Once found, this will define:
# - ROCR_FOUND - ROCR status (found or not found)
# - ROCR_INCLUDES - Required ROCR include directories
# - ROCR_LIBRARIES - Required ROCR libraries
find_path(FIND_ROCR_INCLUDES hsa.h HINTS /opt/rocm/include /opt/rocm/hsa/include PATH_SUFFIXES hsa)
find_library(FIND_ROCR_LIBRARIES hsa-runtime64 HINTS /opt/rocm/lib /opt/rocm/hsa/lib)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(ROCR DEFAULT_MSG
FIND_ROCR_INCLUDES FIND_ROCR_LIBRARIES)
mark_as_advanced(FIND_ROCR_INCLUDES FIND_ROCR_LIBRARIES)
set(ROCR_INCLUDES ${FIND_ROCR_INCLUDES})
set(ROCR_LIBRARIES ${FIND_ROCR_LIBRARIES})
projects/hip/cmake/FindROCT.cmake
+16
View File
@@ -0,0 +1,16 @@
# Try to find ROCT (Radeon Open Compute Thunk)
#
# Once found, this will define:
# - ROCT_FOUND - ROCT status (found or not found)
# - ROCT_INCLUDES - Required ROCT include directories
# - ROCT_LIBRARIES - Required ROCT libraries
find_path(FIND_ROCT_INCLUDES hsakmt.h HINTS /opt/rocm/include)
find_library(FIND_ROCT_LIBRARIES hsakmt HINTS /opt/rocm/lib)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(ROCT DEFAULT_MSG
FIND_ROCT_INCLUDES FIND_ROCT_LIBRARIES)
mark_as_advanced(FIND_ROCT_INCLUDES FIND_ROCT_LIBRARIES)
set(ROCT_INCLUDES ${FIND_ROCT_INCLUDES})
set(ROCT_LIBRARIES ${FIND_ROCT_LIBRARIES})
projects/hip/configure
Vendored
View File
projects/hip/packaging/hip-vdi.txt
+55
View File
@@ -0,0 +1,55 @@
cmake_minimum_required(VERSION 2.8.3)
project(hip_vdi)
install(FILES @PROJECT_BINARY_DIR@/lib/libamdhip64.so DESTINATION lib)
install(FILES @PROJECT_BINARY_DIR@/lib/libhip_hcc.so DESTINATION lib)
if(NOT @HIP_COMPILER@ STREQUAL "clang")
install(FILES @PROJECT_BINARY_DIR@/libhiprtc.so DESTINATION lib)
endif()
install(FILES @PROJECT_BINARY_DIR@/.hipInfo DESTINATION lib)
install(FILES @PROJECT_BINARY_DIR@/hip-config.cmake @PROJECT_BINARY_DIR@/hip-config-version.cmake DESTINATION lib/cmake/hip)
install(FILES @hip_SOURCE_DIR@/packaging/hip-targets.cmake @hip_SOURCE_DIR@/packaging/hip-targets-release.cmake DESTINATION lib/cmake/hip)
#############################
# Packaging steps
#############################
set(CPACK_SET_DESTDIR TRUE)
set(CPACK_INSTALL_PREFIX "/opt/rocm/hip")
set(CPACK_PACKAGE_NAME "hip-vdi")
set(HCC_PACKAGE_NAME "vdi")
set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "HIP: Heterogenous-computing Interface for Portability [VDI]")
set(CPACK_PACKAGE_VENDOR "Advanced Micro Devices, Inc.")
set(CPACK_PACKAGE_CONTACT "Maneesh Gupta <maneesh.gupta@amd.com>")
set(CPACK_PACKAGE_VERSION @HIP_VERSION_MAJOR@.@HIP_VERSION_MINOR@.@HIP_VERSION_PATCH@)
set(CPACK_PACKAGE_VERSION_MAJOR @HIP_VERSION_MAJOR@)
set(CPACK_PACKAGE_VERSION_MINOR @HIP_VERSION_MINOR@)
set(CPACK_PACKAGE_VERSION_PATCH @HIP_VERSION_PATCH@)
set(CPACK_PACKAGE_FILE_NAME ${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH})
set(CPACK_GENERATOR "TGZ;DEB;RPM")
set(CPACK_BINARY_DEB "ON")
set(CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA "${PROJECT_BINARY_DIR}/postinst;${PROJECT_BINARY_DIR}/prerm")
if(@COMPILE_HIP_ATP_MARKER@)
set(CPACK_DEBIAN_PACKAGE_DEPENDS "hip-base (= ${CPACK_PACKAGE_VERSION}), ${HCC_PACKAGE_NAME} (= @HCC_PACKAGE_VERSION@), rocm-profiler, comgr (>= 1.1)")
else()
set(CPACK_DEBIAN_PACKAGE_DEPENDS "hip-base (= ${CPACK_PACKAGE_VERSION}), ${HCC_PACKAGE_NAME} (= @HCC_PACKAGE_VERSION@), comgr (>= 1.1)")
endif()
set(CPACK_DEBIAN_PACKAGE_PROVIDES "hip_vdi")
set(CPACK_DEBIAN_PACKAGE_REPLACES "hip_vdi")
set(CPACK_DEBIAN_PACKAGE_CONFLICTS "hip_vdi")
set(CPACK_BINARY_RPM "ON")
set(CPACK_RPM_PACKAGE_ARCHITECTURE "${CMAKE_SYSTEM_PROCESSOR}")
set(CPACK_RPM_POST_INSTALL_SCRIPT_FILE "${PROJECT_BINARY_DIR}/postinst")
set(CPACK_RPM_PRE_UNINSTALL_SCRIPT_FILE "${PROJECT_BINARY_DIR}/prerm")
set(CPACK_RPM_PACKAGE_AUTOREQPROV " no")
string(REPLACE "-" "_" HIP_BASE_VERSION ${CPACK_PACKAGE_VERSION})
if(@COMPILE_HIP_ATP_MARKER@)
set(CPACK_RPM_PACKAGE_REQUIRES "hip-base = ${HIP_BASE_VERSION}, rocm-profiler, comgr >= 1.1")
#set(CPACK_RPM_PACKAGE_REQUIRES "hip-base = ${HIP_BASE_VERSION}, ${HCC_PACKAGE_NAME} = @HCC_PACKAGE_VERSION@, rocm-profiler, comgr >= 1.1")
else()
set(CPACK_RPM_PACKAGE_REQUIRES "hip-base = ${HIP_BASE_VERSION}, comgr >= 1.1")
endif()
set(CPACK_RPM_PACKAGE_OBSOLETES "hip_vdi")
set(CPACK_RPM_PACKAGE_CONFLICTS "hip_vdi")
set(CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION "/opt")
set(CPACK_SOURCE_GENERATOR "TGZ")
include(CPack)
projects/hip/tests/hit/HIT.cmake
+8 -8
View File
@@ -75,7 +75,7 @@ macro(PARSE_BUILD_COMMAND _target _sources _hipcc_options _hcc_options _nvcc_opt
elseif(_link_options_found)
list(APPEND ${_link_options} ${arg})
elseif(_exclude_platforms_found)
set(${_exclude_platforms} ${arg})
list(APPEND ${_exclude_platforms} ${arg})
elseif(_depends_found)
list(APPEND ${_depends} ${arg})
else()
@@ -106,7 +106,7 @@ macro(PARSE_CUSTOMBUILD_COMMAND _target _buildcmd _exclude_platforms _depends)
set(_depends_found TRUE)
else()
if(_exclude_platforms_found)
set(${_exclude_platforms} ${arg})
list(APPEND ${_exclude_platforms} ${arg})
elseif(_depends_found)
list(APPEND ${_depends} ${arg})
else()
@@ -131,7 +131,7 @@ macro(PARSE_TEST_COMMAND _target _arguments _exclude_platforms)
set(_exclude_platforms_found TRUE)
else()
if(_exclude_platforms_found)
set(${_exclude_platforms} ${arg})
list(APPEND ${_exclude_platforms} ${arg})
else()
list(APPEND ${_arguments} ${arg})
endif()
@@ -158,7 +158,7 @@ macro(PARSE_TEST_NAMED_COMMAND _target _testname _arguments _exclude_platforms)
set(_exclude_platforms_found TRUE)
else()
if(_exclude_platforms_found)
set(${_exclude_platforms} ${arg})
list(APPEND ${_exclude_platforms} ${arg})
else()
list(APPEND ${_arguments} ${arg})
endif()
@@ -206,7 +206,7 @@ macro(HIT_ADD_FILES _dir _label _parent)
parse_build_command(_target _sources _hipcc_options _hcc_options _nvcc_options _link_options _exclude_platforms _depends ${_dir} ${_cmd})
string(REGEX REPLACE "/" "." target ${_label}/${_target})
insert_into_map("_exclude" "${target}" "${_exclude_platforms}")
if(_exclude_platforms STREQUAL "all" OR _exclude_platforms STREQUAL ${HIP_PLATFORM})
if("all" IN_LIST _exclude_platforms OR ${HIP_PLATFORM} IN_LIST _exclude_platforms)
else()
set_source_files_properties(${_sources} PROPERTIES HIP_SOURCE_PROPERTY_FORMAT 1)
hip_reset_flags()
@@ -239,7 +239,7 @@ macro(HIT_ADD_FILES _dir _label _parent)
parse_custombuild_command(_target _buildcmd _exclude_platforms _depends ${_cmd})
string(REGEX REPLACE "/" "." target ${_label}/${_target})
insert_into_map("_exclude" "${target}" "${_exclude_platforms}")
if(_exclude_platforms STREQUAL "all" OR _exclude_platforms STREQUAL ${HIP_PLATFORM})
if("all" IN_LIST _exclude_platforms OR ${HIP_PLATFORM} IN_LIST _exclude_platforms)
else()
string(REGEX REPLACE ";" " " _buildcmd "${_buildcmd}")
#string(CONCAT buildscript ${CMAKE_CURRENT_BINARY_DIR}/${target} ".sh")
@@ -266,7 +266,7 @@ macro(HIT_ADD_FILES _dir _label _parent)
parse_test_command(_target _arguments _exclude_platforms ${_cmd})
string(REGEX REPLACE "/" "." target ${_label}/${_target})
read_from_map("_exclude" "${target}" _exclude_platforms_from_build)
if(_exclude_platforms STREQUAL "all" OR _exclude_platforms STREQUAL ${HIP_PLATFORM} OR
if("all" IN_LIST _exclude_platforms OR ${HIP_PLATFORM} IN_LIST _exclude_platforms OR
_exclude_platforms_from_build STREQUAL "all" OR _exclude_platforms_from_build STREQUAL ${HIP_PLATFORM})
else()
make_test(${_label}/${_target} ${_arguments})
@@ -285,7 +285,7 @@ macro(HIT_ADD_FILES _dir _label _parent)
parse_test_named_command(_target _testname _arguments _exclude_platforms ${_cmd})
string(REGEX REPLACE "/" "." target ${_label}/${_target})
read_from_map("_exclude" "${target}" _exclude_platforms_from_build)
if(_exclude_platforms STREQUAL "all" OR _exclude_platforms STREQUAL ${HIP_PLATFORM} OR
if("all" IN_LIST _exclude_platforms OR ${HIP_PLATFORM} IN_LIST _exclude_platforms OR
_exclude_platforms_from_build STREQUAL "all" OR _exclude_platforms_from_build STREQUAL ${HIP_PLATFORM})
else()
make_named_test(${_label}/${_target} ${_label}/${_testname}.tst ${_arguments})
projects/hip/tests/src/dynamicLoading/complex_loading_behavior.cpp
+1 -1
View File
@@ -22,7 +22,7 @@ THE SOFTWARE.
/* HIT_START
* BUILD_CMD: libfoo_amd %hc %S/%s -o libfoo.so -Xcompiler -fPIC -lpthread -shared -DTEST_SHARED_LIBRARY EXCLUDE_HIP_PLATFORM nvcc
* BUILD_CMD: libfoo_nvidia %hc %S/%s -o libfoo.so -Xcompiler -fPIC -lpthread -shared -DTEST_SHARED_LIBRARY EXCLUDE_HIP_PLATFORM hcc
* BUILD_CMD: libfoo_nvidia %hc %S/%s -o libfoo.so -Xcompiler -fPIC -lpthread -shared -DTEST_SHARED_LIBRARY EXCLUDE_HIP_PLATFORM hcc vdi
* BUILD_CMD: %t %hc %S/%s -o %T/%t -ldl
* TEST: %t
* HIT_END
projects/hip/tests/src/gcc/hipMalloc.c
+2 -2
View File
@@ -18,9 +18,9 @@
* */
/* HIT_START
* BUILD_CMD: hipMalloc %cc -D__HIP_PLATFORM_NVCC__ -I%hip-path/include -I/usr/local/cuda/include %S/%s -o %T/hipMalloc_nv -L/usr/local/cuda/lib64 -lcudart EXCLUDE_HIP_PLATFORM hcc
* BUILD_CMD: hipMalloc %cc -D__HIP_PLATFORM_NVCC__ -I%hip-path/include -I/usr/local/cuda/include %S/%s -o %T/hipMalloc_nv -L/usr/local/cuda/lib64 -lcudart EXCLUDE_HIP_PLATFORM hcc vdi
* BUILD_CMD: hipMalloc %cc -D__HIP_PLATFORM_HCC__ -I%hip-path/include %S/%s -Wl,--rpath=%hip-path/lib %hip-path/lib/libhip_hcc.so -o %T/hipMalloc_hcc EXCLUDE_HIP_PLATFORM nvcc
* TEST: hipMalloc_nv EXCLUDE_HIP_PLATFORM hcc
* TEST: hipMalloc_nv EXCLUDE_HIP_PLATFORM hcc vdi
* TEST: hipMalloc_hcc EXCLUDE_HIP_PLATFORM nvcc
* HIT_END
*/
projects/hip/tests/src/kernel/hipDynamicShared.cpp
+1 -1
View File
@@ -21,7 +21,7 @@ THE SOFTWARE.
*/
/* HIT_START
* BUILD: %t %s ../test_common.cpp EXCLUDE_HIP_PLATFORM hcc
* BUILD: %t %s ../test_common.cpp EXCLUDE_HIP_PLATFORM hcc vdi
* TEST: %t EXCLUDE_HIP_PLATFORM nvcc
* HIT_END
*/
projects/hip/tests/src/kernel/hipDynamicShared2.cpp
+1 -1
View File
@@ -21,7 +21,7 @@ THE SOFTWARE.
*/
/* HIT_START
* BUILD: %t %s ../test_common.cpp EXCLUDE_HIP_PLATFORM hcc
* BUILD: %t %s ../test_common.cpp EXCLUDE_HIP_PLATFORM hcc vdi
* TEST: %t EXCLUDE_HIP_PLATFORM nvcc
* HIT_END
*/
projects/hip/tests/src/p2p/hipPeerToPeer_simple.cpp
+3 -3
View File
@@ -24,9 +24,9 @@ THE SOFTWARE.
/* HIT_START
* BUILD: %t %s ../test_common.cpp
* TEST: %t EXCLUDE_HIP_PLATFORM hcc
* TEST: %t --memcpyWithPeer EXCLUDE_HIP_PLATFORM hcc
* TEST: %t --mirrorPeers EXCLUDE_HIP_PLATFORM hcc
* TEST: %t EXCLUDE_HIP_PLATFORM hcc vdi
* TEST: %t --memcpyWithPeer EXCLUDE_HIP_PLATFORM hcc vdi
* TEST: %t --mirrorPeers EXCLUDE_HIP_PLATFORM hcc vdi
* HIT_END
*/
projects/hip/vdi/CMakeLists.txt
+198
View File
@@ -0,0 +1,198 @@
#project("hip")
cmake_minimum_required(VERSION 3.5.1)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--no-keep-memory -Wl,-Bsymbolic -Wl,--unresolved-symbols=report-all -Wl,--version-script=${CMAKE_CURRENT_LIST_DIR}/hip_hcc.map.in")
if(CMAKE_CXX_FLAGS MATCHES "fsanitize=address")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -shared-libasan")
endif()
set (CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
add_definitions(-D__HIP_VDI__ -D__HIP_PLATFORM_HCC__ -DLINUX -D__x86_64__ -D__AMD64__ -DUNIX_OS -DqLittleEndian -DOPENCL_MAJOR=2 -DOPENCL_MINOR=0 -DWITH_AQL -DWITH_ONLINE_COMPILER -DATI_OS_LINUX -DATI_ARCH_X86 -DLITTLEENDIAN_CPU -DATI_BITS_64 -DATI_COMP_GCC -DWITH_HSA_DEVICE -DWITH_TARGET_AMDGCN -DOPENCL_EXPORTS -DCL_USE_DEPRECATED_OPENCL_1_0_APIS -DCL_USE_DEPRECATED_OPENCL_1_1_APIS -DCL_USE_DEPRECATED_OPENCL_1_2_APIS -DCL_USE_DEPRECATED_OPENCL_2_0_APIS -DVEGA10_ONLY=false -DWITH_LIGHTNING_COMPILER -DUSE_PROF_API)
if(CMAKE_BUILD_TYPE MATCHES "^Debug$")
add_definitions(-DDEBUG)
endif()
#command example:
#cmake -DVDI_DIR=/home/pghafari/vdi/vdi -DLIBOCL_STATIC_DIR=/home/pghafari/git-ocl/build/amdocl -DLIBVDI_STATIC_DIR=/home/pghafari/vdi/vdi/build -DUSE_COMGR_LIBRARY=yes -DCMAKE_BUILD_TYPE=Debug -DCMAKE_PREFIX_PATH="/home/pghafari/rocmgitvdi/hsa-runtime/opensrc/hsa-runtime/build;/home/pghafari/rocmgitvdi/hsa-runtime/opensrc;/home/pghafari/rocmgitvdi/support/lib/comgr;/home/pghafari/rocmgitvdi/support/lib/comgr/build;" -DCMAKE_MODULE_PATH=/home/pghafari/rocmgit/opencl/cmake/modules -DLLVM_INCLUDES=/home/pghafari/rocmgit/llvm-project/llvm/include ..
set(USE_PROF_API "1")
find_package(ROCT REQUIRED)
find_package(ROCR REQUIRED)
if(NOT DEFINED LIBVDI_STATIC_DIR)
find_path(LIBVDI_STATIC_DIR
NAMES libamdvdi_static.a
PATHS /opt/rocm/vdi
PATH_SUFFIXES lib
)
endif()
if(NOT DEFINED VDI_DIR)
find_path(VDI_DIR
NAMES top.hpp
PATH_SUFFIXES include
PATHS /opt/rocm/vdi
)
endif()
message("vdilib:${LIBVDI_STATIC_DIR} ,found vdi includes ${VDI_DIR}")
set(PROF_API_HEADER_PATH ${VDI_DIR}/platform)
#############################
# Profiling API support
#############################
# Generate profiling API macros/structures header
set(PROF_API_STR "${CMAKE_CURRENT_SOURCE_DIR}/../include/hip/hcc_detail/hip_prof_str.h")
set(PROF_API_HDR "${CMAKE_CURRENT_SOURCE_DIR}/../include/hip/hcc_detail/hip_runtime_api.h")
set(PROF_API_SRC "${CMAKE_CURRENT_SOURCE_DIR}")
set(PROF_API_GEN "${CMAKE_CURRENT_SOURCE_DIR}/hip_prof_gen.py")
set(PROF_API_LOG "${PROJECT_BINARY_DIR}/hip_prof_gen.log.txt")
set(PROF_API_CMD "${PROF_API_GEN} -v -t --priv ${OPT_PROF_API} ${PROF_API_HDR} ${PROF_API_SRC} ${PROF_API_STR} >${PROF_API_LOG}")
MESSAGE(STATUS "Generating profiling promitives: ${PROF_API_STR}")
execute_process(COMMAND sh -c "rm -f ${PROF_API_STR}; ${PROF_API_CMD}")
MESSAGE(COMMAND sh -c "rm -f ${PROF_API_STR}; ${PROF_API_CMD}")
set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS ${PROF_API_GEN} ${PROF_API_HDR} ${PROF_API_STR})
# Enable profiling API
if(USE_PROF_API EQUAL 1)
find_path(PROF_API_HEADER_DIR prof_protocol.h
HINTS
${PROF_API_HEADER_PATH}
PATHS
/opt/rocm/roctracer
PATH_SUFFIXES
include/ext
)
if(NOT PROF_API_HEADER_DIR)
MESSAGE(WARNING "Profiling API header not found. Disabling roctracer integration. Use -DPROF_API_HEADER_PATH=<path to prof_protocol.h header>")
else()
add_definitions(-DUSE_PROF_API=1)
include_directories(${PROF_API_HEADER_DIR})
MESSAGE(STATUS "Profiling API: ${PROF_API_HEADER_DIR}")
endif()
endif()
if(NOT DEFINED VDI_DIR OR NOT DEFINED LIBOCL_STATIC_DIR OR NOT DEFINED LIBVDI_STATIC_DIR )
# message(FATAL_ERROR "define VDI_DIR, LIBOCL_STATIC_DIR\n")
endif()
list ( APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules" )
set(CMAKE_MODULE_PATH${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake" "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules")
include_directories(${ROCR_INCLUDES})
if (DEFINED LLVM_INCLUDES AND NOT ${LLVM_INCLUDES} STREQUAL "")
message(STATUS "LLVM includes found ${LLVM_INCLUDES}")
include_directories(${LLVM_INCLUDES})
endif() # if (DEFINED LLVM_INCLUDES AND NOT ${LLVM_INCLUDES} STREQUAL "")
#find_package(hsa-runtime REQUIRED CONFIG PATHS ${HSA_RUNTIME} NO_DEFAULT_PATH)
include_directories(${CMAKE_SOURCE_DIR})
include_directories(${CMAKE_SOURCE_DIR}/include)
include_directories(${CMAKE_SOURCE_DIR}/elfio)
include_directories(${CMAKE_SOURCE_DIR}/amdocl)
include_directories(${CMAKE_SOURCE_DIR}/include/hip/hcc_detail/elfio)
include_directories(${VDI_DIR})
include_directories(${VDI_DIR}/include)
include_directories(${VDI_DIR}/compiler/lib)
include_directories(${VDI_DIR}/compiler/lib/include)
include_directories(${VDI_DIR}/compiler/lib/loaders)
include_directories(${VDI_DIR}/compiler/lib/loaders/elf/utils/common)
include_directories(${VDI_DIR}/compiler/lib/loaders/elf/utils/libelf)
add_definitions(-DUSE_COMGR_LIBRARY -DCOMGR_DYN_DLL)
find_package(amd_comgr REQUIRED CONFIG
PATHS
/opt/rocm/
PATH_SUFFIXES
cmake/amd_comgr
lib/cmake/amd_comgr
)
MESSAGE(STATUS "Code Object Manager found at ${amd_comgr_DIR}.")
#find_package(amd_comgr REQUIRED CONFIG)
include_directories("$<TARGET_PROPERTY:amd_comgr,INTERFACE_INCLUDE_DIRECTORIES>")
add_definitions(-DBSD_LIBELF)
#find_package( Threads REQUIRED CONFIG)
#find_package( LibElf REQUIRED CONFIG)
add_library(amdhip64 SHARED
hip_context.cpp
hip_device.cpp
hip_device_runtime.cpp
hip_error.cpp
hip_event.cpp
hip_memory.cpp
hip_module.cpp
hip_peer.cpp
hip_platform.cpp
hip_profile.cpp
hip_stream.cpp
hip_surface.cpp
hip_texture.cpp
hip_activity.cpp
hip_intercept.cpp
hip_rtc.cpp
cl_gl.cpp
cl_icd.cpp
cl_lqdflash_amd.cpp
)
add_library(amdvdi_static STATIC IMPORTED)
set_target_properties(amdvdi_static PROPERTIES IMPORTED_LOCATION "${LIBVDI_STATIC_DIR}/libamdvdi_static.a")
#add_library(amdocl64 SHARED IMPORTED)
#set_target_properties(amdocl64 PROPERTIES IMPORTED_LOCATION "/opt/rocm/opencl/lib/x86_64/libamdocl64.so")
#add_library(oclelf STATIC IMPORTED)
#set_target_properties(oclelf PROPERTIES IMPORTED_LOCATION "${LIBOCLELF_STATIC_DIR}/liboclelf.a")
add_library(host INTERFACE)
target_link_libraries(host INTERFACE amdhip64)
add_library(device INTERFACE)
target_link_libraries(device INTERFACE host)
#target_link_libraries(amdhip64 PRIVATE amd_comgr)
target_link_libraries(amdhip64 amdvdi_static pthread dl ${ROCT_LIBRARIES} ${ROCR_LIBRARIES})
#target_link_libraries(amdhip64 amdvdi_static amdocl64_static pthread dl ${ROCT_LIBRARIES} ${ROCR_LIBRARIES})
#install(CODE "execute_process( COMMAND ${CMAKE_COMMAND} -E create_symlink libamdhip64.so lib/libhip_hcc.so)" )
install(TARGETS amdhip64 LIBRARY DESTINATION lib/x86_64 COMPONENT applications)
install(PROGRAMS $<TARGET_FILE:amdhip64>
DESTINATION lib
COMPONENT MAIN)
INSTALL(CODE "execute_process( COMMAND ${CMAKE_COMMAND} -E create_symlink libamdhip64.so lib/libhip_hcc.so )" DESTINATION lib COMPONENT MAIN)
INSTALL(FILES ${CMAKE_BINARY_DIR}/lib/libhip_hcc.so DESTINATION lib COMPONENT MAIN)
if(0)
set(CPACK_GENERATOR "DEB;RPM" CACHE STRING "Default packaging generators")
set(CPACK_PACKAGE_CONTACT "Advanced Micro Devices Inc.")
set(CPACK_PACKAGE_VENDOR "AMD")
set(CPACK_PACKAGING_INSTALL_PREFIX "/opt/rocm/hip-on-vdi")
set(CPACK_PACKAGE_VERSION_MAJOR "1")
set(CPACK_PACKAGE_VERSION_MINOR "0")
set(CPACK_PACKAGE_VERSION_PATCH "0")
# Debian CPACK variables
set(CPACK_DEB_COMPONENT_INSTALL ON)
set(CPACK_DEBIAN_MAIN_FILE_NAME "hip-on-vdi-1.0.0.deb")
set(CPACK_DEBIAN_MAIN_PACKAGE_NAME "hip-on-vdi")
#set(CPACK_DEBIAN_MAIN_PACKAGE_CONTROL_EXTRA "${CMAKE_CURRENT_SOURCE_DIR}/DEB/postinst;${CMAKE_CURRENT_SOURCE_DIR}/DEB/prerm")
# RPM CPACK variables
set(CPACK_RPM_COMPONENT_INSTALL ON)
set(CPACK_RPM_MAIN_FILE_NAME "hip-on-vdi-1.0.0.rpm")
set(CPACK_RPM_MAIN_PACKAGE_NAME "hip-on-vdi")
#set(CPACK_RPM_MAIN_POST_INSTALL_SCRIPT_FILE "${CMAKE_CURRENT_SOURCE_DIR}/RPM/rpm_post")
#set(CPACK_RPM_MAIN_POST_UNINSTALL_SCRIPT_FILE "${CMAKE_CURRENT_SOURCE_DIR}/RPM/rpm_postun")
set(CPACK_COMPONENTS_ALL MAIN)
include(CPack)
endif()
projects/hip/vdi/cl_gl.cpp
+2416
View File
File diff suppressed because it is too large Load Diff
projects/hip/vdi/cl_gl_amd.hpp
+363
View File
@@ -0,0 +1,363 @@
//
// Copyright 2010 Advanced Micro Devices, Inc. All rights reserved.
//
#ifndef CL_GL_AMD_HPP_
#define CL_GL_AMD_HPP_
#ifdef _WIN32
#include <windows.h>
#else //!_WIN32
#include <dlfcn.h>
#endif //!_WIN32
#include <GL/gl.h>
#include <GL/glext.h>
#include "CL/cl_gl.h"
#ifndef _WIN32
#include <GL/glx.h>
#endif //!_WIN32
#include <EGL/egl.h>
#include <EGL/eglext.h>
#include <EGL/eglplatform.h>
#include "platform/context.hpp"
#include "platform/command.hpp"
namespace amd
{
//! Class GLObject keeps all the info about the GL object
//! from which the CL object is created
class GLObject : public InteropObject
{
protected:
cl_gl_object_type clGLType_; //!< CL GL object type
GLenum glTarget_;
GLuint gluiName_;
GLint gliMipLevel_;
GLenum glInternalFormat_;
GLint gliWidth_;
GLint gliHeight_;
GLint gliDepth_;
GLenum glCubemapFace_;
GLsizei glNumSamples_;
public:
//! GLObject constructor initializes member variables
GLObject(
GLenum glTarget,
GLuint gluiName,
GLint gliMipLevel,
GLenum glInternalFormat,
GLint gliWidth,
GLint gliHeight,
GLint gliDepth,
cl_gl_object_type clGLType,
GLenum glCubemapFace,
GLsizei glNumSamples
): // Initialization of member variables
clGLType_(clGLType),
glTarget_(glTarget),
gluiName_(gluiName),
gliMipLevel_(gliMipLevel),
glInternalFormat_(glInternalFormat),
gliWidth_(gliWidth),
gliHeight_(gliHeight),
gliDepth_(gliDepth),
glCubemapFace_(glCubemapFace),
glNumSamples_(glNumSamples)
{
}
virtual ~GLObject() {}
virtual GLObject* asGLObject() {return this;}
//! GLObject query functions to get GL info from member variables
GLenum getGLTarget() const {return glTarget_;}
GLuint getGLName() const {return gluiName_;}
GLint getGLMipLevel() const {return gliMipLevel_;}
GLenum getGLInternalFormat() const {return glInternalFormat_;}
GLint getGLSize() const {return gliWidth_;}
GLint getGLWidth() const {return gliWidth_;}
GLint getGLHeight() const {return gliHeight_;}
GLint getGLDepth() const {return gliDepth_;}
cl_gl_object_type getCLGLObjectType() const { return clGLType_; }
GLenum getCubemapFace() const {return glCubemapFace_;}
GLsizei getNumSamples() const { return glNumSamples_;}
};
//! Class BufferGL is drived from classes Buffer and GLObject
//! where the former keeps all data for CL object and
//! the latter keeps all data for GL object
class BufferGL : public Buffer, public GLObject
{
protected:
//! Initializes the device memory array which is nested
// after'BufferGL' object in memory layout.
virtual void initDeviceMemory();
public:
//! BufferGL constructor just calls constructors of base classes
//! to pass down the parameters
BufferGL(
Context& amdContext,
cl_mem_flags clFlags,
size_t uiSizeInBytes,
GLenum glTarget,
GLuint gluiName)
: // Call base classes constructors
Buffer(
amdContext,
clFlags,
uiSizeInBytes
),
GLObject(
glTarget,
gluiName,
0, // Mipmap level default
GL_ARRAY_BUFFER, // Just init to some value
(GLint) uiSizeInBytes,
1,
1,
CL_GL_OBJECT_BUFFER,
0,
0
)
{
setInteropObj(this);
}
virtual ~BufferGL() {}
virtual BufferGL* asBufferGL() { return this; }
};
//! Class ImageGL is derived from classes Image and GLObject
//! where the former keeps all data for CL object and
//! the latter keeps all data for GL object
class ImageGL : public Image, public GLObject
{
public:
//! ImageGL constructor just calls constructors of base classes
//! to pass down the parameters
ImageGL(
Context& amdContext,
cl_mem_object_type clType,
cl_mem_flags clFlags,
const Format& format,
size_t width,
size_t height,
size_t depth,
GLenum glTarget,
GLuint gluiName,
GLint gliMipLevel,
GLenum glInternalFormat,
cl_gl_object_type clGLType,
GLsizei numSamples,
GLenum glCubemapFace = 0)
: Image(amdContext, clType, clFlags, format, width, height, depth,
Format(format).getElementSize() * width,
Format(format).getElementSize() * width * depth)
, GLObject(glTarget, gluiName, gliMipLevel, glInternalFormat,
static_cast<GLint>(width), static_cast<GLint>(height),
static_cast<GLint>(depth), clGLType, glCubemapFace,numSamples)
{
setInteropObj(this);
}
virtual ~ImageGL() {}
protected:
//! Initializes the device memory array which is nested
// after'BufferGL' object in memory layout.
virtual void initDeviceMemory();
};
#ifdef _WIN32
#define APICALL WINAPI
#define GETPROCADDRESS GetProcAddress
#define API_GETPROCADDR "wglGetProcAddress"
#define FCN_STR_TYPE LPCSTR
typedef PROC (WINAPI* PFN_xxxGetProcAddress) (LPCSTR fcnName);
typedef HGLRC (APICALL* PFN_wglCreateContext) (HDC hdc);
typedef HGLRC (APICALL* PFN_wglGetCurrentContext) (void);
typedef HDC (APICALL* PFN_wglGetCurrentDC) (void);
typedef BOOL (APICALL* PFN_wglDeleteContext) (HGLRC hglrc);
typedef BOOL (APICALL* PFN_wglMakeCurrent) (HDC hdc, HGLRC hglrc);
typedef BOOL (APICALL* PFN_wglShareLists) (HGLRC hglrc1, HGLRC hglrc2);
#else //!_WIN32
#define APICALL // __stdcall //??? todo odintsov
#define API_GETPROCADDR "glXGetProcAddress"
#define GETPROCADDRESS dlsym
#define FCN_STR_TYPE const GLubyte*
#define WINAPI
#define PROC void*
typedef void* (*PFN_xxxGetProcAddress) (const GLubyte* procName);
// X11 typedef
typedef Display* (*PFNXOpenDisplay)(_Xconst char* display_name );
typedef int (*PFNXCloseDisplay)(Display* display );
//glx typedefs
typedef GLXDrawable (*PFNglXGetCurrentDrawable)();
typedef Display* (*PFNglXGetCurrentDisplay)();
typedef GLXContext (*PFNglXGetCurrentContext)( void );
typedef XVisualInfo* (*PFNglXChooseVisual)(Display *dpy, int screen, int *attribList);
typedef GLXContext(*PFNglXCreateContext)(Display* dpy,XVisualInfo* vis,GLXContext shareList,Bool direct);
typedef void(*PFNglXDestroyContext)(Display* dpy, GLXContext ctx);
typedef Bool(*PFNglXMakeCurrent)( Display* dpy, GLXDrawable drawable, GLXContext ctx);
typedef void* HMODULE;
#endif //!_WIN32
#define GLPREFIX(rtype, fcn, dclargs) \
typedef rtype (APICALL* PFN_##fcn) dclargs;
// Declare prototypes for GL functions
#include "gl_functions.hpp"
class GLFunctions
{
public:
//! Locks any access to the virtual GPUs
class SetIntEnv : public amd::StackObject {
public:
//! Default constructor
SetIntEnv(GLFunctions* env);
//! Destructor
~SetIntEnv();
//! Checks if the environment setup was successful
bool isValid() const { return isValid_; }
private:
GLFunctions* env_; //!< GL environment
bool isValid_; //!< If TRUE, then it's a valid setup
};
private:
HMODULE libHandle_;
int missed_; // Indicates how many GL functions not init'ed, if any
amd::Monitor lock_;
EGLDisplay eglDisplay_;
EGLContext eglOriginalContext_;
EGLContext eglInternalContext_;
EGLContext eglTempContext_;
bool isEGL_;
#ifdef _WIN32
HGLRC hOrigGLRC_;
HDC hDC_;
HGLRC hIntGLRC_; // handle for internal GLRC to access shared context
HDC tempDC_;
HGLRC tempGLRC_;
PFN_wglCreateContext wglCreateContext_;
PFN_wglGetCurrentContext wglGetCurrentContext_;
PFN_wglGetCurrentDC wglGetCurrentDC_;
PFN_wglDeleteContext wglDeleteContext_;
PFN_wglMakeCurrent wglMakeCurrent_;
PFN_wglShareLists wglShareLists_;
#else
public:
Display* Dpy_;
GLXDrawable Drawable_;
GLXContext origCtx_;
Display* intDpy_;
Window intDrawable_;
GLXContext intCtx_;
Display* tempDpy_;
GLXDrawable tempDrawable_;
GLXContext tempCtx_;
//pointers to X11 functions
PFNXOpenDisplay XOpenDisplay_;
PFNXCloseDisplay XCloseDisplay_;
//pointers to GLX functions
PFNglXGetCurrentDrawable glXGetCurrentDrawable_;
PFNglXGetCurrentDisplay glXGetCurrentDisplay_;
PFNglXGetCurrentContext glXGetCurrentContext_;
PFNglXChooseVisual glXChooseVisual_;
PFNglXCreateContext glXCreateContext_;
PFNglXDestroyContext glXDestroyContext_;
PFNglXMakeCurrent glXMakeCurrent_;
#endif
public:
GLFunctions(HMODULE h, bool isEGL);
~GLFunctions();
// Query CL-GL context association
bool isAssociated() const
{
if (isEGL_ && eglDisplay_ && eglOriginalContext_) return true;
#ifdef _WIN32
if(hDC_ && hOrigGLRC_) return true;
#else //!_WIN32
if(Dpy_ && origCtx_) return true;
#endif //!_WIN32
return false;
}
bool isEGL() const
{
return isEGL_;
}
// Accessor methods
#ifdef _WIN32
HGLRC getOrigGLRC() const {return hOrigGLRC_;}
HDC getDC() const {return hDC_;}
HGLRC getIntGLRC() const {return hIntGLRC_;}
#else //!_WIN32
Display* getDpy() const {return Dpy_;}
GLXDrawable getDrawable() const {return Drawable_;}
GLXContext getOrigCtx() const {return origCtx_;}
Display* getIntDpy() const {return intDpy_;}
GLXDrawable getIntDrawable() const {return intDrawable_;}
GLXContext getIntCtx() const {return intCtx_;}
EGLDisplay getEglDpy() const { return eglDisplay_; }
EGLContext getEglOrigCtx() const { return eglOriginalContext_; }
#endif //!_WIN32
// Initialize GL dynamic library and function pointers
bool init(intptr_t hdc, intptr_t hglrc);
// Return true if successful, false - if error occurred
bool setIntEnv();
bool restoreEnv();
amd::Monitor& getLock() { return lock_; }
PFN_xxxGetProcAddress GetProcAddress_;
#define GLPREFIX(rtype, fcn, dclargs) \
PFN_##fcn fcn##_;
// Declare pointers to GL functions
#include "gl_functions.hpp"
};
//! Functions for executing the GL related stuff
cl_mem clCreateFromGLBufferAMD(Context& amdContext, cl_mem_flags flags,
GLuint bufobj, cl_int* errcode_ret);
cl_mem clCreateFromGLTextureAMD(Context& amdContext, cl_mem_flags flags,
GLenum target, GLint miplevel, GLuint texture, int* errcode_ret);
cl_mem clCreateFromGLRenderbufferAMD(Context& amdContext, cl_mem_flags flags,
GLuint renderbuffer, int* errcode_ret);
bool
getCLFormatFromGL(
const Context& amdContext,
GLint gliInternalFormat,
cl_image_format* pclImageFormat,
int* piBytesPerPixel,
cl_mem_flags flags
);
} //namespace amd
#endif //CL_GL_AMD_HPP_
projects/hip/vdi/cl_icd.cpp
+279
View File
@@ -0,0 +1,279 @@
//
// Copyright (c) 2008 Advanced Micro Devices, Inc. All rights reserved.
//
#include "cl_common.hpp"
#ifdef _WIN32
#include <d3d10_1.h>
#include "cl_d3d9_amd.hpp"
#include "cl_d3d10_amd.hpp"
#include "cl_d3d11_amd.hpp"
#endif //_WIN32
#include <icd/loader/icd_dispatch.h>
#include <mutex>
amd::PlatformIDS amd::PlatformID::Platform = //{ NULL };
{amd::ICDDispatchedObject::icdVendorDispatch_};
static cl_int CL_API_CALL icdGetPlatformInfo(cl_platform_id platform, cl_platform_info param_name,
size_t param_value_size, void* param_value,
size_t* param_value_size_ret) {
return NULL ; //clGetPlatformInfo(NULL, param_name, param_value_size, param_value, param_value_size_ret);
}
static cl_int CL_API_CALL icdGetDeviceIDs(cl_platform_id platform, cl_device_type device_type,
cl_uint num_entries, cl_device_id* devices,
cl_uint* num_devices) {
return NULL ;//clGetDeviceIDs(NULL, device_type, num_entries, devices, num_devices);
}
static cl_int CL_API_CALL icdGetDeviceInfo(cl_device_id device, cl_device_info param_name,
size_t param_value_size, void* param_value,
size_t* param_value_size_ret) {
if (param_name == CL_DEVICE_PLATFORM) {
// Return the ICD platform instead of the default NULL platform.
cl_platform_id platform = reinterpret_cast<cl_platform_id>(&amd::PlatformID::Platform);
return amd::clGetInfo(platform, param_value_size, param_value, param_value_size_ret);
}
return NULL ; //clGetDeviceInfo(device, param_name, param_value_size, param_value, param_value_size_ret);
}
KHRicdVendorDispatch amd::ICDDispatchedObject::icdVendorDispatch_[] = {
{NULL /* should not get called */, icdGetPlatformInfo, icdGetDeviceIDs, icdGetDeviceInfo}
#if 0
clCreateContext, clCreateContextFromType, clRetainContext, clReleaseContext, clGetContextInfo,
clCreateCommandQueue, clRetainCommandQueue, clReleaseCommandQueue, clGetCommandQueueInfo,
clSetCommandQueueProperty, clCreateBuffer, clCreateImage2D, clCreateImage3D, clRetainMemObject,
clReleaseMemObject, clGetSupportedImageFormats, clGetMemObjectInfo, clGetImageInfo,
clCreateSampler, clRetainSampler, clReleaseSampler, clGetSamplerInfo,
clCreateProgramWithSource, clCreateProgramWithBinary, clRetainProgram, clReleaseProgram,
clBuildProgram, clUnloadCompiler, clGetProgramInfo, clGetProgramBuildInfo, clCreateKernel,
clCreateKernelsInProgram, clRetainKernel, clReleaseKernel, clSetKernelArg, clGetKernelInfo,
clGetKernelWorkGroupInfo, clWaitForEvents, clGetEventInfo, clRetainEvent, clReleaseEvent,
clGetEventProfilingInfo, clFlush, clFinish, clEnqueueReadBuffer, clEnqueueWriteBuffer,
clEnqueueCopyBuffer, clEnqueueReadImage, clEnqueueWriteImage, clEnqueueCopyImage,
clEnqueueCopyImageToBuffer, clEnqueueCopyBufferToImage, clEnqueueMapBuffer, clEnqueueMapImage,
clEnqueueUnmapMemObject, clEnqueueNDRangeKernel, clEnqueueTask, clEnqueueNativeKernel,
clEnqueueMarker, clEnqueueWaitForEvents, clEnqueueBarrier, clGetExtensionFunctionAddress,
clCreateFromGLBuffer, clCreateFromGLTexture2D, clCreateFromGLTexture3D,
clCreateFromGLRenderbuffer, clGetGLObjectInfo, clGetGLTextureInfo, clEnqueueAcquireGLObjects,
clEnqueueReleaseGLObjects, clGetGLContextInfoKHR,
WINDOWS_SWITCH(clGetDeviceIDsFromD3D10KHR, NULL),
WINDOWS_SWITCH(clCreateFromD3D10BufferKHR, NULL),
WINDOWS_SWITCH(clCreateFromD3D10Texture2DKHR, NULL),
WINDOWS_SWITCH(clCreateFromD3D10Texture3DKHR, NULL),
WINDOWS_SWITCH(clEnqueueAcquireD3D10ObjectsKHR, NULL),
WINDOWS_SWITCH(clEnqueueReleaseD3D10ObjectsKHR, NULL), clSetEventCallback, clCreateSubBuffer,
clSetMemObjectDestructorCallback, clCreateUserEvent, clSetUserEventStatus,
clEnqueueReadBufferRect, clEnqueueWriteBufferRect, clEnqueueCopyBufferRect,
NULL, NULL, NULL, clCreateEventFromGLsyncKHR,
/* OpenCL 1.2*/
clCreateSubDevices, clRetainDevice, clReleaseDevice, clCreateImage,
clCreateProgramWithBuiltInKernels, clCompileProgram, clLinkProgram, clUnloadPlatformCompiler,
clGetKernelArgInfo, clEnqueueFillBuffer, clEnqueueFillImage, clEnqueueMigrateMemObjects,
clEnqueueMarkerWithWaitList, clEnqueueBarrierWithWaitList,
clGetExtensionFunctionAddressForPlatform, clCreateFromGLTexture,
WINDOWS_SWITCH(clGetDeviceIDsFromD3D11KHR, NULL),
WINDOWS_SWITCH(clCreateFromD3D11BufferKHR, NULL),
WINDOWS_SWITCH(clCreateFromD3D11Texture2DKHR, NULL),
WINDOWS_SWITCH(clCreateFromD3D11Texture3DKHR, NULL),
WINDOWS_SWITCH(clCreateFromDX9MediaSurfaceKHR, NULL),
WINDOWS_SWITCH(clEnqueueAcquireD3D11ObjectsKHR, NULL),
WINDOWS_SWITCH(clEnqueueReleaseD3D11ObjectsKHR, NULL),
WINDOWS_SWITCH(clGetDeviceIDsFromDX9MediaAdapterKHR,
NULL), // KHRpfn_clGetDeviceIDsFromDX9MediaAdapterKHR
// clGetDeviceIDsFromDX9MediaAdapterKHR;
WINDOWS_SWITCH(
clEnqueueAcquireDX9MediaSurfacesKHR,
NULL), // KHRpfn_clEnqueueAcquireDX9MediaSurfacesKHR clEnqueueAcquireDX9MediaSurfacesKHR;
WINDOWS_SWITCH(
clEnqueueReleaseDX9MediaSurfacesKHR,
NULL), // KHRpfn_clEnqueueReleaseDX9MediaSurfacesKHR clEnqueueReleaseDX9MediaSurfacesKHR;
NULL,
NULL, NULL, NULL,
clCreateCommandQueueWithProperties, clCreatePipe, clGetPipeInfo, clSVMAlloc, clSVMFree,
clEnqueueSVMFree, clEnqueueSVMMemcpy, clEnqueueSVMMemFill, clEnqueueSVMMap, clEnqueueSVMUnmap,
clCreateSamplerWithProperties, clSetKernelArgSVMPointer, clSetKernelExecInfo,
clGetKernelSubGroupInfo,
clCloneKernel,
clCreateProgramWithIL,
clEnqueueSVMMigrateMem,
clGetDeviceAndHostTimer,
clGetHostTimer,
clGetKernelSubGroupInfo,
clSetDefaultDeviceCommandQueue,
clSetProgramReleaseCallback,
clSetProgramSpecializationConstant }
#endif
};
#if defined(ATI_OS_WIN)
#include <Shlwapi.h>
#pragma comment(lib, "shlwapi.lib")
static bool ShouldLoadPlatform() {
// Get the OpenCL ICD registry values
HKEY platformsKey = NULL;
if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, "SOFTWARE\\Khronos\\OpenCL\\Vendors", 0, KEY_READ,
&platformsKey) != ERROR_SUCCESS)
return true;
std::vector<std::string> registryValues;
DWORD dwIndex = 0;
while (true) {
char cszLibraryName[1024] = {0};
DWORD dwLibraryNameSize = sizeof(cszLibraryName);
DWORD dwLibraryNameType = 0;
DWORD dwValue = 0;
DWORD dwValueSize = sizeof(dwValue);
if (RegEnumValueA(platformsKey, dwIndex++, cszLibraryName, &dwLibraryNameSize, NULL,
&dwLibraryNameType, (LPBYTE)&dwValue, &dwValueSize) != ERROR_SUCCESS)
break;
// Require that the value be a DWORD and equal zero
if (dwLibraryNameType != REG_DWORD || dwValue != 0) {
continue;
}
registryValues.push_back(cszLibraryName);
}
RegCloseKey(platformsKey);
HMODULE hm = NULL;
if (!GetModuleHandleExA(
GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
(LPCSTR)&ShouldLoadPlatform, &hm))
return true;
char cszDllPath[1024] = {0};
if (!GetModuleFileNameA(hm, cszDllPath, sizeof(cszDllPath))) return true;
// If we are loaded from the DriverStore, then there should be a registry
// value matching our current module absolute path.
if (std::find(registryValues.begin(), registryValues.end(), cszDllPath) == registryValues.end())
return true;
LPSTR cszFileName;
char buffer[1024] = {0};
if (!GetFullPathNameA(cszDllPath, sizeof(buffer), buffer, &cszFileName)) return true;
// We found an absolute path in the registry that matched this DLL, now
// check if there is also an entry with the same filename.
if (std::find(registryValues.begin(), registryValues.end(), cszFileName) == registryValues.end())
return true;
// Lastly, check if there is a DLL with the same name in the System folder.
char cszSystemPath[1024] = {0};
#if defined(ATI_BITS_32)
if (!GetSystemWow64DirectoryA(cszSystemPath, sizeof(cszSystemPath)))
#endif // defined(ATI_BITS_32)
if (!GetSystemDirectoryA(cszSystemPath, sizeof(cszSystemPath))) return true;
std::string systemDllPath;
systemDllPath.append(cszSystemPath).append("\\").append(cszFileName);
if (!PathFileExistsA(systemDllPath.c_str())) {
return true;
}
// If we get here, then all 3 conditions are true:
// - An entry in the registry with an absolute path matches the current DLL
// - An entry in the registry with a relative path matches the current DLL
// - A DLL with the same name was found in the system directory
//
// We should not load this platform!
return false;
}
#else
#include <dlfcn.h>
// If there is only one platform, load it.
// If there is more than one platform, only load platforms that have visible devices
// If all platforms have no devices available, only load the PAL platform
static bool ShouldLoadPlatform() {
bool shouldLoad = true;
if (!amd::Runtime::initialized()) {
amd::Runtime::init();
}
const int numDevices = amd::Device::numDevices(CL_DEVICE_TYPE_GPU, false);
void *otherPlatform = nullptr;
if (amd::IS_LEGACY) {
otherPlatform = dlopen("libamdocl64.so", RTLD_LAZY);
if (otherPlatform != nullptr) { // Present platform exists
shouldLoad = numDevices > 0;
}
} else {
otherPlatform = dlopen("libamdocl-orca64.so", RTLD_LAZY);
if (otherPlatform != nullptr) { // Legacy platform exists
// gcc4.8 doesn't support casting void* to a function pointer
// Work around this by creating a typedef untill we upgrade the compiler
typedef void*(*clGetFunctionAddress_t)(const char *);
typedef cl_int(*clIcdGetPlatformIDs_t)(cl_uint, cl_platform_id *, cl_uint *);
clGetFunctionAddress_t legacyGetFunctionAddress =
reinterpret_cast<clGetFunctionAddress_t>(dlsym(otherPlatform, "clGetExtensionFunctionAddress"));
clIcdGetPlatformIDs_t legacyGetPlatformIDs =
reinterpret_cast<clIcdGetPlatformIDs_t>(legacyGetFunctionAddress("clIcdGetPlatformIDsKHR"));
cl_uint numLegacyPlatforms = 0;
legacyGetPlatformIDs(0, nullptr, &numLegacyPlatforms);
shouldLoad = (numDevices > 0) || (numLegacyPlatforms == 0);
}
}
if (otherPlatform != nullptr) {
dlclose(otherPlatform);
}
return shouldLoad;
}
#endif // defined(ATI_OS_WIN)
CL_API_ENTRY cl_int CL_API_CALL clIcdGetPlatformIDsKHR(cl_uint num_entries,
cl_platform_id* platforms,
cl_uint* num_platforms) {
if (((num_entries > 0 || num_platforms == NULL) && platforms == NULL) ||
(num_entries == 0 && platforms != NULL)) {
return CL_INVALID_VALUE;
}
static bool shouldLoad = true;
static std::once_flag initOnce;
std::call_once(initOnce, [](){ shouldLoad = ShouldLoadPlatform(); });
if (!shouldLoad) {
*not_null(num_platforms) = 0;
return CL_SUCCESS;
}
if (!amd::Runtime::initialized()) {
amd::Runtime::init();
}
if (num_platforms != NULL && platforms == NULL) {
*num_platforms = 1;
return CL_SUCCESS;
}
assert(platforms != NULL && "check the code above");
*platforms = reinterpret_cast<cl_platform_id>(&amd::PlatformID::Platform);
*not_null(num_platforms) = 1;
return CL_SUCCESS;
}
projects/hip/vdi/cl_lqdflash_amd.cpp
+294
View File
@@ -0,0 +1,294 @@
//
// Copyright (c) 2015 Advanced Micro Devices, Inc. All rights reserved.
//
#include "cl_common.hpp"
#include <CL/cl_ext.h>
#include "platform/object.hpp"
#include "cl_lqdflash_amd.h"
#if (!defined(BUILD_HSA_TARGET) && defined(WITH_HSA_DEVICE) && \
defined(WITH_AMDGPU_PRO)) || defined(_WIN32) || defined(WITH_PAL_DEVICE)
#define WITH_LIQUID_FLASH 1
#endif // _WIN32
#if defined(WITH_LIQUID_FLASH)
#include "lf.h"
#include <locale>
#include <codecvt>
#endif // WITH_LIQUID_FLASH
namespace amd {
LiquidFlashFile::~LiquidFlashFile() { close(); }
bool LiquidFlashFile::open() {
#if defined WITH_LIQUID_FLASH
lf_status err;
lf_file_flags flags = 0;
switch (flags_) {
case CL_FILE_READ_ONLY_AMD:
flags = LF_READ;
break;
case CL_FILE_WRITE_ONLY_AMD:
flags = LF_WRITE;
break;
case CL_FILE_READ_WRITE_AMD:
flags = LF_READ | LF_WRITE;
break;
}
#ifdef ATI_OS_LINUX
assert(sizeof(wchar_t) != sizeof(lf_char));
std::string name_char;
std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t> cv;
name_char = cv.to_bytes(name_);
handle_ = lfOpenFile(name_char.c_str(), flags, &err);
#else
handle_ = lfOpenFile(name_.c_str(), flags, &err);
#endif
if (err != lf_success) {
return false;
}
if (lfGetFileBlockSize((lf_file)handle_, &blockSize_) != lf_success) {
return false;
}
if (lfGetFileSize((lf_file)handle_, &fileSize_) != lf_success) {
return false;
}
return true;
#else
return false;
#endif // WITH_LIQUID_FLASH
}
void LiquidFlashFile::close() {
#if defined WITH_LIQUID_FLASH
if (handle_ != NULL) {
lfReleaseFile((lf_file)handle_);
handle_ = NULL;
}
#endif // WITH_LIQUID_FLASH
}
bool LiquidFlashFile::transferBlock(bool writeBuffer, void* srcDst, uint64_t bufferSize,
uint64_t fileOffset, uint64_t bufferOffset,
uint64_t size) const {
#if defined WITH_LIQUID_FLASH
lf_status status;
lf_region_descriptor region = {fileOffset / blockSize(), bufferOffset / blockSize(),
size / blockSize()};
if (writeBuffer) {
status = lfReadFile(srcDst, bufferSize, (lf_file)handle_, 1, &region, NULL);
} else {
status = lfWriteFile(srcDst, bufferSize, (lf_file)handle_, 1, &region, NULL);
}
if (lf_success == status) {
return true;
} else {
return false;
}
#else
return false;
#endif // WITH_LIQUID_FLASH
}
} // namespace amd
/*! \addtogroup API
* @{
*
* \addtogroup AMD_Extensions
* @{
*
*/
RUNTIME_ENTRY_RET(cl_file_amd, clCreateSsgFileObjectAMD,
(cl_context context, cl_file_flags_amd flags, const wchar_t* file_name,
cl_int* errcode_ret)) {
#if defined WITH_LIQUID_FLASH && defined ATI_OS_LINUX
if (!is_valid(context)) {
*not_null(errcode_ret) = CL_INVALID_CONTEXT;
LogWarning("invalid parameter \"context\"");
return (cl_file_amd)0;
}
const std::vector<amd::Device*>& devices = as_amd(context)->devices();
bool supportPass = false;
for (auto& dev : devices) {
if (lf_success == lfCheckExtensionSupportForDevice(dev->info().pcieDeviceId_,
dev->info().pcieRevisionId_)) {
supportPass = true;
break;
}
}
if (!supportPass) {
*not_null(errcode_ret) = CL_INVALID_DEVICE;
LogWarning("SSG isn't supported");
return (cl_file_amd)0;
}
#endif
amd::LiquidFlashFile* file = new amd::LiquidFlashFile(file_name, flags);
if (file == NULL) {
*not_null(errcode_ret) = CL_OUT_OF_HOST_MEMORY;
return (cl_file_amd)0;
}
if (!file->open()) {
*not_null(errcode_ret) = CL_INVALID_VALUE;
delete file;
return (cl_file_amd)0;
}
*not_null(errcode_ret) = CL_SUCCESS;
return as_cl(file);
}
RUNTIME_EXIT
RUNTIME_ENTRY(cl_int, clGetSsgFileObjectInfoAMD,
(cl_file_amd file, cl_file_info_amd param_name, size_t param_value_size,
void* param_value, size_t* param_value_size_ret)) {
if (!is_valid(file)) {
return CL_INVALID_FILE_OBJECT_AMD;
}
switch (param_name) {
case CL_FILE_BLOCK_SIZE_AMD: {
cl_uint blockSize = as_amd(file)->blockSize();
return amd::clGetInfo(blockSize, param_value_size, param_value, param_value_size_ret);
}
case CL_FILE_SIZE_AMD: {
cl_ulong fileSize = as_amd(file)->fileSize();
return amd::clGetInfo(fileSize, param_value_size, param_value, param_value_size_ret);
}
default:
break;
}
return CL_INVALID_VALUE;
}
RUNTIME_EXIT
RUNTIME_ENTRY(cl_int, clRetainSsgFileObjectAMD, (cl_file_amd file)) {
if (!is_valid(file)) {
return CL_INVALID_FILE_OBJECT_AMD;
}
as_amd(file)->retain();
return CL_SUCCESS;
}
RUNTIME_EXIT
RUNTIME_ENTRY(cl_int, clReleaseSsgFileObjectAMD, (cl_file_amd file)) {
if (!is_valid(file)) {
return CL_INVALID_FILE_OBJECT_AMD;
}
as_amd(file)->release();
return CL_SUCCESS;
}
RUNTIME_EXIT
static cl_int EnqueueTransferBufferFromSsgFileAMD(
cl_bool isWrite, cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_write,
size_t buffer_offset, size_t cb, cl_file_amd file, size_t file_offset,
cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event) {
if (!is_valid(command_queue)) {
return CL_INVALID_COMMAND_QUEUE;
}
if (!is_valid(buffer)) {
return CL_INVALID_MEM_OBJECT;
}
amd::Buffer* pBuffer = as_amd(buffer)->asBuffer();
if (pBuffer == NULL) {
return CL_INVALID_MEM_OBJECT;
}
if (pBuffer->getMemFlags() & (CL_MEM_HOST_READ_ONLY | CL_MEM_HOST_NO_ACCESS)) {
return CL_INVALID_OPERATION;
}
amd::HostQueue* queue = as_amd(command_queue)->asHostQueue();
if (NULL == queue) {
return CL_INVALID_COMMAND_QUEUE;
}
amd::HostQueue& hostQueue = *queue;
if (hostQueue.context() != pBuffer->getContext()) {
return CL_INVALID_CONTEXT;
}
if (!is_valid(file)) {
return CL_INVALID_FILE_OBJECT_AMD;
}
amd::LiquidFlashFile* amdFile = as_amd(file);
amd::Coord3D bufferOffset(buffer_offset, 0, 0);
amd::Coord3D bufferSize(cb, 1, 1);
if ((!pBuffer->validateRegion(bufferOffset, bufferSize)) ||
// LF library supports aligned sizes only
((buffer_offset % amdFile->blockSize()) != 0) || ((cb % amdFile->blockSize()) != 0) ||
((file_offset % amdFile->blockSize()) != 0)) {
return CL_INVALID_VALUE;
}
amd::Command::EventWaitList eventWaitList;
cl_int err = amd::clSetEventWaitList(eventWaitList, hostQueue, num_events_in_wait_list,
event_wait_list);
if (err != CL_SUCCESS) {
return err;
}
amd::TransferBufferFileCommand* command;
command = new amd::TransferBufferFileCommand(
isWrite ? CL_COMMAND_READ_SSG_FILE_AMD : CL_COMMAND_WRITE_SSG_FILE_AMD, hostQueue,
eventWaitList, *pBuffer, bufferOffset, bufferSize, amdFile, file_offset);
if (command == NULL) {
return CL_OUT_OF_HOST_MEMORY;
}
// Make sure we have memory for the command execution
if (!command->validateMemory()) {
delete command;
return CL_MEM_OBJECT_ALLOCATION_FAILURE;
}
command->enqueue();
if (blocking_write) {
command->awaitCompletion();
}
*not_null(event) = as_cl(&command->event());
if (event == NULL) {
command->release();
}
return CL_SUCCESS;
}
RUNTIME_ENTRY(cl_int, clEnqueueReadSsgFileAMD,
(cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_write,
size_t buffer_offset, size_t cb, cl_file_amd file, size_t file_offset,
cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event)) {
return EnqueueTransferBufferFromSsgFileAMD(CL_TRUE, command_queue, buffer, blocking_write,
buffer_offset, cb, file, file_offset,
num_events_in_wait_list, event_wait_list, event);
}
RUNTIME_EXIT
RUNTIME_ENTRY(cl_int, clEnqueueWriteSsgFileAMD,
(cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_write,
size_t buffer_offset, size_t cb, cl_file_amd file, size_t file_offset,
cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event)) {
return EnqueueTransferBufferFromSsgFileAMD(CL_FALSE, command_queue, buffer, blocking_write,
buffer_offset, cb, file, file_offset,
num_events_in_wait_list, event_wait_list, event);
}
RUNTIME_EXIT
projects/hip/vdi/cl_lqdflash_amd.h
+42
View File
@@ -0,0 +1,42 @@
//
// Copyright (c) 2015 Advanced Micro Devices, Inc. All rights reserved.
//
#ifndef __CL_LQDFLASH_AMD_H
#define __CL_LQDFLASH_AMD_H
#include "CL/cl_ext.h"
#ifdef __cplusplus
extern "C" {
#endif /*__cplusplus*/
extern CL_API_ENTRY cl_file_amd CL_API_CALL
clCreateSsgFileObjectAMD(cl_context context, cl_file_flags_amd flags, const wchar_t* file_name,
cl_int* errcode_ret) CL_EXT_SUFFIX__VERSION_1_2;
extern CL_API_ENTRY cl_int CL_API_CALL clGetSsgFileObjectInfoAMD(
cl_file_amd file, cl_file_info_amd param_name, size_t param_value_size, void* param_value,
size_t* param_value_size_ret) CL_EXT_SUFFIX__VERSION_1_2;
extern CL_API_ENTRY cl_int CL_API_CALL clRetainSsgFileObjectAMD(cl_file_amd file)
CL_EXT_SUFFIX__VERSION_1_2;
extern CL_API_ENTRY cl_int CL_API_CALL clReleaseSsgFileObjectAMD(cl_file_amd file)
CL_EXT_SUFFIX__VERSION_1_2;
extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadSsgFileAMD(
cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_write, size_t buffer_offset,
size_t cb, cl_file_amd file, size_t file_offset, cl_uint num_events_in_wait_list,
const cl_event* event_wait_list, cl_event* event) CL_EXT_SUFFIX__VERSION_1_2;
extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteSsgFileAMD(
cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_write, size_t buffer_offset,
size_t cb, cl_file_amd file, size_t file_offset, cl_uint num_events_in_wait_list,
const cl_event* event_wait_list, cl_event* event) CL_EXT_SUFFIX__VERSION_1_2;
#ifdef __cplusplus
} /*extern "C"*/
#endif /*__cplusplus*/
#endif
projects/hip/vdi/hip_prof_gen.py
Executable
+610
View File
@@ -0,0 +1,610 @@
#!/usr/bin/python
# Copyright (c) 2019 - present Advanced Micro Devices, Inc. All rights reserved.
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in 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:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# 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
# AUTHORS 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 IN
# THE SOFTWARE.
import os, sys, re
PROF_HEADER = "hip_prof_str.h"
OUTPUT = PROF_HEADER
REC_MAX_LEN = 1024
# Recursive sources processing
recursive_mode = 0
# HIP_INIT_API macro patching
hip_patch_mode = 0
# API matching types check
types_check_mode = 0
# Private API check
private_check_mode = 0
# Messages and errors controll
verbose = 0
errexit = 0
inp_file = 'none'
line_num = -1
# Verbose message
def message(msg):
if verbose: sys.stdout.write(msg + '\n')
# Fatal error termination
def error(msg):
if line_num != -1:
msg += ", file '" + inp_file + "', line (" + str(line_num) + ")"
if errexit:
msg = " Error: " + msg
else:
msg = " Warning: " + msg
sys.stdout.write(msg + '\n')
sys.stderr.write(sys.argv[0] + msg +'\n')
def fatal(msg):
error(msg)
sys.exit(1)
#############################################################
# Normalizing API name
def filtr_api_name(name):
name = re.sub(r'\s*$', r'', name);
return name
def filtr_api_decl(record):
record = re.sub("\s__dparm\([^\)]*\)", '', record);
record = re.sub("\(void\*\)", '', record);
return record
# Normalizing API arguments
def filtr_api_args(args_str):
args_str = re.sub(r'^\s*', r'', args_str);
args_str = re.sub(r'\s*$', r'', args_str);
args_str = re.sub(r'\s*,\s*', r',', args_str);
args_str = re.sub(r'\s+', r' ', args_str);
#args_str = re.sub(r'void \*', r'void* ', args_str);
args_str = re.sub(r'\s*(\*+)\s*', r'\1 ', args_str);
args_str = re.sub(r'(enum|struct) ', '', args_str);
return args_str
# Normalizing types
def norm_api_types(type_str):
type_str = re.sub(r'uint32_t', r'unsigned int', type_str)
type_str = re.sub(r'^unsigned$', r'unsigned int', type_str)
return type_str
# Creating a list of arguments [(type, name), ...]
def list_api_args(args_str):
args_str = filtr_api_args(args_str)
args_list = []
if args_str != '':
for arg_pair in args_str.split(','):
if arg_pair == 'void': continue
arg_pair = re.sub(r'\s*=\s*\S+$','', arg_pair);
m = re.match("^(.*)\s(\S+)$", arg_pair);
if m:
arg_type = norm_api_types(m.group(1))
arg_name = m.group(2)
args_list.append((arg_type, arg_name))
else:
fatal("bad args: args_str: '" + args_str + "' arg_pair: '" + arg_pair + "'")
return args_list;
# Creating arguments string "type0, type1, ..."
def filtr_api_types(args_str):
args_list = list_api_args(args_str)
types_str = ''
for arg_tuple in args_list:
types_str += arg_tuple[0] + ', '
return types_str
# Creating options list [opt0, opt1, ...]
def filtr_api_opts(args_str):
args_list = list_api_args(args_str)
opts_list = []
for arg_tuple in args_list:
opts_list.append(arg_tuple[1])
return opts_list
#############################################################
# Parsing API header
# hipError_t hipSetupArgument(const void* arg, size_t size, size_t offset);
def parse_api(inp_file_p, out):
global inp_file
global line_num
inp_file = inp_file_p
beg_pattern = re.compile("^(hipError_t|const char\s*\*)\s+([^\(]+)\(");
api_pattern = re.compile("^(hipError_t|const char\s*\*)\s+([^\(]+)\(([^\)]*)\)");
end_pattern = re.compile("Texture");
hidden_pattern = re.compile(r'__attribute__\(\(visibility\("hidden"\)\)\)')
nms_open_pattern = re.compile(r'namespace hip_impl {')
nms_close_pattern = re.compile(r'}')
inp = open(inp_file, 'r')
found = 0
hidden = 0
nms_level = 0;
record = ""
line_num = -1
for line in inp.readlines():
record += re.sub(r'^\s+', r' ', line[:-1])
line_num += 1
if len(record) > REC_MAX_LEN:
fatal("bad record \"" + record + "\"")
m = beg_pattern.match(line)
if m:
name = m.group(2)
if hidden != 0:
message("api: " + name + " - hidden")
elif nms_level != 0:
message("api: " + name + " - hip_impl")
else:
message("api: " + name)
found = 1
if found != 0:
record = re.sub("\s__dparm\([^\)]*\)", '', record);
m = api_pattern.match(record)
if m:
found = 0
if end_pattern.search(record): break
api_name = filtr_api_name(m.group(2))
api_args = m.group(3)
if not api_name in out:
out[api_name] = api_args
else: continue
hidden = 0
if hidden_pattern.match(line): hidden = 1
if nms_open_pattern.match(line): nms_level += 1
if (nms_level > 0) and nms_close_pattern.match(line): nms_level -= 1
if nms_level < 0:
fatal("nms level < 0")
record = ""
inp.close()
line_num = -1
#############################################################
# Parsing API implementation
# hipError_t hipSetupArgument(const void* arg, size_t size, size_t offset) {
# HIP_INIT_API(hipSetupArgument, arg, size, offset);
# inp_file - input implementation source file
# api_map - input public API map [<api name>] => <api args>
# out - output map [<api name>] => [opt0, opt1, ...]
def parse_content(inp_file_p, api_map, out):
global hip_patch_mode
global types_check_mode
global private_check_mode
global inp_file
global line_num
inp_file = inp_file_p
# API method begin pattern
beg_pattern = re.compile("^(hipError_t|const char\s*\*)\s+[^\(]+\(");
# API declaration pattern
decl_pattern = re.compile("^(hipError_t|const char\s*\*)\s+([^\(]+)\(([^\)]*)\)\s*;");
# API definition pattern
api_pattern = re.compile("^(hipError_t|const char\s*\*)\s+([^\(]+)\(([^\)]*)\)\s*{");
# API init macro pattern
init_pattern = re.compile("(^\s*HIP_INIT_API\s*)\((([^,]+)(,.*|)|)(\);|,)\s*$");
# Open input file
inp = open(inp_file, 'r')
# API name
api_name = ""
# Valid public API found flag
api_valid = 0
# Input file patched content
content = ''
# Sub content for found API defiition
sub_content = ''
# Current record, accumulating several API definition related lines
record = ''
# Current input file line number
line_num = -1
# API beginning found flag
found = 0
# Reading input file
for line in inp.readlines():
# Accumulating record
record += re.sub(r'^\s+', r' ', line[:-1])
line_num += 1
if len(record) > REC_MAX_LEN:
fatal("bad record \"" + record + "\"")
break;
# Looking for API begin
if found == 0:
if beg_pattern.match(record):
found = 1
record = filtr_api_decl(record)
# Matching API declaration
if found == 1:
if decl_pattern.match(record):
found = 0
# Matching API definition
if found == 1:
m = api_pattern.match(record)
# Checking if complete API matched
if m:
found = 2
api_name = filtr_api_name(m.group(2))
# Checking if API name is in the API map
if (private_check_mode == 0) or (api_name in api_map):
if not api_name in api_map: api_map[api_name] = ''
# Getting API arguments
api_args = m.group(3)
# Getting etalon arguments from the API map
eta_args = api_map[api_name]
if eta_args == '':
eta_args = api_args
api_map[api_name] = eta_args
# Normalizing API arguments
api_types = filtr_api_types(api_args)
# Normalizing etalon arguments
eta_types = filtr_api_types(eta_args)
if (api_types == eta_types) or ((types_check_mode == 0) and (not api_name in out)):
# API is already found and not is mismatched
if (api_name in out):
fatal("API redefined \"" + api_name + "\", record \"" + record + "\"")
# Set valid public API found flag
api_valid = 1
# Set output API map with API arguments list
out[api_name] = filtr_api_opts(api_args)
# Register missmatched API methods
else:
# Warning about mismatched API, possible non public overloaded version
api_diff = '\t\t' + inp_file + " line(" + str(line_num) + ")\n\t\tapi: " + api_types + "\n\t\teta: " + eta_types
message("\t" + api_name + ' args mismatch:\n' + api_diff + '\n')
if hip_patch_mode != 0:
# Looking for INIT macro
m = init_pattern.match(line)
if m:
if api_valid == 0: api_name = 'NONE'
if api_name == m.group(3):
if hip_patch_mode == 1: hip_patch_mode = 0
else: fatal("patching failed")
else:
hip_patch_mode = 2
init_args = m.group(2)
if init_args != '': init_args = ', ' + init_args
line = m.group(1) + '(' + api_name + init_args + m.group(5) + '\n'
non_public_api = 0
# API found action
if found == 2:
# Looking for INIT macro
m = init_pattern.match(line)
if m:
found = 0
non_public_api = 0
if api_valid == 1:
api_valid = 0
message("\t" + api_name)
else:
non_public_api = 1
if non_public_api == 1:
# Registering dummy API for non public API if the name in INIT is not NONE
init_name = m.group(3)
# Ignore if it is initialized as NONE
if init_name != 'NONE':
# Check if init name matching API name
if init_name != api_name:
fatal("init name mismatch: '" + init_name + "' <> '" + api_name + "'")
# If init name is not in public API map then it is private API
# else it was not identified and will be checked on finish
if not init_name in api_map:
if init_name in out:
fatal("API reinit \"" + api_name + "\", record \"" + record + "\"")
out[init_name] = []
elif re.search('}', line):
found = 0
# Expect INIT macro for valid public API
# Removing and registering non-conformant APIs with missing HIP_INIT macro
if api_valid == 1:
api_valid = 0
if api_name in out:
del out[api_name]
del api_map[api_name]
# Registering non-conformant APIs
out['.' + api_name] = 1
else:
fatal("API is not in out \"" + api_name + "\", record \"" + record + "\"")
if found != 1: record = ""
content += line
inp.close()
line_num = -1
if len(out) != 0:
return content
else:
return ''
# src path walk
def parse_src(api_map, src_path, src_patt, out):
global recursive_mode
pattern = re.compile(src_patt)
src_path = re.sub(r'\s', '', src_path)
for src_dir in src_path.split(':'):
message("Parsing " + src_dir + " for '" + src_patt + "'")
for root, dirs, files in os.walk(src_dir):
for fnm in files:
if pattern.search(fnm):
file = root + '/' + fnm
message(file)
content = parse_content(file, api_map, out);
if (hip_patch_mode != 0) and (content != ''):
f = open(file, 'w')
f.write(content)
f.close()
if recursive_mode == 0: break
#############################################################
# Generating profiling primitives header
# api_map - public API map [<api name>] => [(type, name), ...]
# opts_map - opts map [<api name>] => [opt0, opt1, ...]
def generate_prof_header(f, api_map, opts_map):
# Private API list
priv_lst = []
f.write('// automatically generated sources\n')
f.write('#ifndef _HIP_PROF_STR_H\n');
f.write('#define _HIP_PROF_STR_H\n');
# Generating dummy macro for non-public API
f.write('\n// Dummy API primitives\n')
f.write('#define INIT_NONE_CB_ARGS_DATA(cb_data) {};\n')
for name in opts_map:
if not name in api_map:
opts_lst = opts_map[name]
if len(opts_lst) != 0:
fatal("bad dummy API \"" + name + "\", args: " + str(opts_lst))
f.write('#define INIT_'+ name + '_CB_ARGS_DATA(cb_data) {};\n')
priv_lst.append(name)
for name in priv_lst:
message("Private: " + name)
# Generating the callbacks ID enumaration
f.write('\n// HIP API callbacks ID enumaration\n')
f.write('enum hip_api_id_t {\n')
cb_id = 0
for name in api_map.keys():
f.write(' HIP_API_ID_' + name + ' = ' + str(cb_id) + ',\n')
cb_id += 1
f.write(' HIP_API_ID_NUMBER = ' + str(cb_id) + ',\n')
f.write('\n')
f.write(' HIP_API_ID_NONE = HIP_API_ID_NUMBER,\n')
for name in priv_lst:
f.write(' HIP_API_ID_' + name + ' = HIP_API_ID_NUMBER,\n')
f.write('};\n')
# Generating the callbacks ID enumaration
f.write('\n// Return HIP API string\n')
f.write('inline const char* hip_api_name(const uint32_t id) {\n')
f.write(' switch(id) {\n')
for name in api_map.keys():
f.write(' case HIP_API_ID_' + name + ': return "' + name + '";\n')
f.write(' };\n')
f.write(' return "unknown";\n')
f.write('};\n')
# Generating the callbacks data structure
f.write('\n// HIP API callbacks data structure\n')
f.write(
'struct hip_api_data_t {\n' +
' uint64_t correlation_id;\n' +
' uint32_t phase;\n' +
' union {\n'
)
for name, args in api_map.items():
if len(args) != 0:
f.write(' struct {\n')
for arg_tuple in args:
if arg_tuple[0] == "hipLimit_t":
f.write(' enum ' + arg_tuple[0] + ' ' + arg_tuple[1] + ';\n')
else:
f.write(' ' + arg_tuple[0] + ' ' + arg_tuple[1] + ';\n')
f.write(' } ' + name + ';\n')
f.write(
' } args;\n' +
'};\n'
)
# Generating the callbacks args data filling macros
f.write('\n// HIP API callbacks args data filling macros\n')
for name, args in api_map.items():
f.write('// ' + name + str(args) + '\n')
f.write('#define INIT_' + name + '_CB_ARGS_DATA(cb_data) { \\\n')
if name in opts_map:
opts_list = opts_map[name]
if len(args) != len(opts_list):
fatal("\"" + name + "\" API args and opts mismatch, args: " + str(args) + ", opts: " + str(opts_list))
# API args iterating:
# type is args[<ind>][0]
# name is args[<ind>][1]
for ind in range(0, len(args)):
arg_tuple = args[ind]
arg_type = arg_tuple[0]
fld_name = arg_tuple[1]
arg_name = opts_list[ind]
f.write(' cb_data.args.' + name + '.' + fld_name + ' = (' + arg_type + ')' + arg_name + '; \\\n')
f.write('};\n')
f.write('#define INIT_CB_ARGS_DATA(cb_id, cb_data) INIT_##cb_id##_CB_ARGS_DATA(cb_data)\n')
# Generating the method for the API string, name and parameters
if False:
f.write('\n')
f.write('#if 0\n')
f.write('#include <sstream>\n');
f.write('#include <string>\n');
f.write('// HIP API string method, method name and parameters\n')
f.write('const char* hipApiString(hip_api_id_t id, const hip_api_data_t* data) {\n')
f.write(' std::ostringstream oss;\n')
f.write(' switch (id) {\n')
for name, args in api_map.items():
f.write(' case HIP_API_ID_' + name + ':\n')
f.write(' oss << "' + name + '("')
for ind in range(0, len(args)):
arg_tuple = args[ind]
arg_name = arg_tuple[1]
if ind != 0: f.write(' << ","')
f.write('\n << " ' + arg_name + '=" << data->args.' + name + '.' + arg_name)
f.write('\n << ")";\n')
f.write(' break;\n')
f.write(' default: oss << "unknown";\n')
f.write(' };\n')
f.write(' return strdup(oss.str().c_str());\n')
f.write('};\n')
f.write('#endif\n')
f.write('#endif // _HIP_PROF_STR_H\n');
#############################################################
# main
while len(sys.argv) > 1:
if not re.match(r'-', sys.argv[1]): break
if (sys.argv[1] == '-v'):
verbose = 1
sys.argv.pop(1)
if (sys.argv[1] == '-r'):
recursive_mode = 1
sys.argv.pop(1)
if (sys.argv[1] == '-t'):
types_check_mode = 1
sys.argv.pop(1)
if (sys.argv[1] == '--priv'):
private_check_mode = 1
sys.argv.pop(1)
if (sys.argv[1] == '-e'):
errexit = 1
sys.argv.pop(1)
if (sys.argv[1] == '-p'):
hip_patch_mode = 1
sys.argv.pop(1)
# Usage
if (len(sys.argv) < 3):
fatal ("Usage: " + sys.argv[0] + " [-v] <input HIP API .h file> <patched srcs path> [<output>]\n" +
" -v - verbose messages\n" +
" -r - process source directory recursively\n" +
" -t - API types matching check\n" +
" --priv - private API check\n" +
" -e - on error exit mode\n" +
" -p - HIP_INIT_API macro patching mode\n" +
"\n" +
" Example:\n" +
" $ " + sys.argv[0] + " -v -p -t --priv ./api/hip/include/hip/hcc_detail/hip_runtime_api.h ./api/hip ./api/hip/include/hip/hcc_detail/hip_prof_str.h");
# API header file given as an argument
src_pat = "\.cpp$"
api_hfile = sys.argv[1]
if not os.path.isfile(api_hfile):
fatal("input file '" + api_hfile + "' not found")
# Srcs directory given as an argument
src_dir = sys.argv[2]
if not os.path.isdir(src_dir):
fatal("src directory " + src_dir + "' not found")
if len(sys.argv) > 3: OUTPUT = sys.argv[3]
# API declaration map
api_map = {
'hipSetupArgument': '',
'hipMalloc3DArray': '',
'hipFuncGetAttribute': '',
'hipMemset3DAsync': '',
'hipKernelNameRef': '',
'hipStreamGetPriority': '',
'hipLaunchByPtr': '',
'hipFreeHost': '',
'hipGetErrorName': '',
'hipMemcpy3DAsync': '',
'hipMemcpyParam2DAsync': '',
'hipArray3DCreate': '',
'hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags': '',
'hipOccupancyMaxPotentialBlockSize': '',
'hipMallocManaged': '',
'hipOccupancyMaxActiveBlocksPerMultiprocessor': '',
'hipGetErrorString': '',
'hipMallocHost': '',
'hipModuleLoadDataEx': '',
'hipGetDeviceProperties': '',
'hipConfigureCall': '',
}
# API options map
opts_map = {}
# Parsing API header
parse_api(api_hfile, api_map)
# Parsing sources
parse_src(api_map, src_dir, src_pat, opts_map)
# Checking for non-conformant APIs with missing HIP_INIT macro
for name in list(opts_map.keys()):
m = re.match(r'\.(\S*)', name)
if m:
message("Init missing: " + m.group(1))
del opts_map[name]
# Converting api map to map of lists
# Checking for not found APIs
not_found = 0
if len(opts_map) != 0:
for name in api_map.keys():
args_str = api_map[name];
api_map[name] = list_api_args(args_str)
if not name in opts_map:
error("implementation not found: " + name)
not_found += 1
if not_found != 0:
error(str(not_found) + " API calls missing in interception layer")
# Generating output header file
with open(OUTPUT, 'w') as f:
generate_prof_header(f, api_map, opts_map)
# Successfull exit
sys.exit(0)