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

Change-Id: I22c145d39f430ca571a981687bcb034ea6e3b8a2


[ROCm/hip commit: a8b81e96b4]

projects/hip/CMakeLists.txt

@@ -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()
+  elseif (HIP_PLATFORM STREQUAL "vdi")
-    set(HIP_RUNTIME $ENV{HIP_RUNTIME} CACHE STRING "HIP Runtime")
+    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")
+#if (HIP_PLATFORM STREQUAL "hcc")
-    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/lpl_ca)
+#    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/lpl_ca)
-endif ()
+#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_egl.h

@@ -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

@@ -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

@@ -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

@@ -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/opencl.h

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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/cmake/FindROCR.cmake

@@ -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

@@ -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/packaging/hip-vdi.txt

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -24,9 +24,9 @@ THE SOFTWARE.
 
 /* HIT_START
  * BUILD: %t %s ../test_common.cpp
- * TEST: %t EXCLUDE_HIP_PLATFORM hcc
+ * TEST: %t EXCLUDE_HIP_PLATFORM hcc vdi
- * TEST: %t --memcpyWithPeer EXCLUDE_HIP_PLATFORM hcc
+ * TEST: %t --memcpyWithPeer EXCLUDE_HIP_PLATFORM hcc vdi
- * TEST: %t --mirrorPeers EXCLUDE_HIP_PLATFORM hcc
+ * TEST: %t --mirrorPeers EXCLUDE_HIP_PLATFORM hcc vdi
  * HIT_END
  */
 

projects/hip/vdi/CMakeLists.txt

@@ -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_amd.hpp

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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)