pax_global_header00006660000000000000000000000064147733154060014524gustar00rootroot0000000000000052 comment=2faf7063c91fdb0f2471f98bf5b2c49c8f907423 ocl-icd-2.3.3/000077500000000000000000000000001477331540600130435ustar00rootroot00000000000000ocl-icd-2.3.3/.github/000077500000000000000000000000001477331540600144035ustar00rootroot00000000000000ocl-icd-2.3.3/.github/workflows/000077500000000000000000000000001477331540600164405ustar00rootroot00000000000000ocl-icd-2.3.3/.github/workflows/presubmit.yml000066400000000000000000000050541477331540600212010ustar00rootroot00000000000000name: Presubmit on: [push, pull_request] jobs: pre_job: runs-on: ubuntu-latest outputs: should_skip: ${{ steps.skip_check.outputs.should_skip }} steps: - id: skip_check uses: fkirc/skip-duplicate-actions@v3.4.0 with: concurrent_skipping: 'same_content' skip_after_successful_duplicate: 'true' paths_ignore: '["README", "COPYING", "INSTALL", "NEWS"]' do_not_skip: '["pull_request"]' build-and-check: needs: pre_job if: ${{ needs.pre_job.outputs.should_skip != 'true' }} name: Build and Check ${{ matrix.os }} ${{ matrix.name }} runs-on: ${{ matrix.os }} strategy: matrix: os: [ubuntu-latest, macos-latest] steps: - uses: actions/checkout@v4 - run: brew install automake libtool if: ${{ matrix.os == 'macos-latest' }} - run: ./bootstrap - run: ./configure --enable-official-khronos-headers - run: make - run: make check - uses: actions/upload-artifact@v4 if: failure() with: name: build-and-check path: | tests/testsuite.log distcheck: needs: pre_job if: ${{ needs.pre_job.outputs.should_skip != 'true' }} name: Distcheck Ubuntu runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - run: ./bootstrap - run: ./configure --enable-official-khronos-headers - run: make distcheck DISTCHECK_CONFIGURE_FLAGS=--enable-official-khronos-headers build-and-check-official-headers: needs: pre_job if: ${{ needs.pre_job.outputs.should_skip != 'true' }} name: Build and Check Ubuntu Official Headers runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - name: Dependencies uses: actions/checkout@v4 with: repository: KhronosGroup/OpenCL-Headers path: OpenCL-Headers - run: ./bootstrap - run: ./configure - run: make - run: make check env: CPATH: ${{ github.workspace }}/OpenCL-Headers:$CPATH distcheck-official-headers: needs: pre_job if: ${{ needs.pre_job.outputs.should_skip != 'true' }} name: Distcheck Ubuntu Official Headers runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - name: Dependencies uses: actions/checkout@v4 with: repository: KhronosGroup/OpenCL-Headers path: OpenCL-Headers - run: ./bootstrap - run: ./configure - run: make distcheck env: CPATH: ${{ github.workspace }}/OpenCL-Headers:$CPATH ocl-icd-2.3.3/.gitignore000066400000000000000000000004001477331540600150250ustar00rootroot00000000000000/autom4te.cache/ /aclocal.m4 /build-aux/ /config.guess /config.sub /config.h.in /config.h.in~ /m4/libtool.m4 /m4/lt~obsolete.m4 /m4/ltoptions.m4 /m4/ltsugar.m4 /m4/ltversion.m4 /tests/package.m4 /tests/testsuite /configure Makefile.in /ocl-icd-*.tar.gz ocl-icd-2.3.3/COPYING000066400000000000000000000025641477331540600141050ustar00rootroot00000000000000Copyright (c) 2012-2020, Brice Videau Copyright (c) 2012-2020, Vincent Danjean All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ocl-icd-2.3.3/INSTALL000066400000000000000000000371361477331540600141060ustar00rootroot00000000000000Installation Instructions ************************* Copyright (C) 1994-1996, 1999-2002, 2004-2012 Free Software Foundation, Inc. Copying and distribution of this file, with or without modification, are permitted in any medium without royalty provided the copyright notice and this notice are preserved. This file is offered as-is, without warranty of any kind. Basic Installation ================== If you start from the Git repository, you first need to run the './bootstrap' script (with all autotool software installed). If you start from a released tarball, this step and autotool software are not required. Briefly, the shell commands './configure; make; make install' should configure, build, and install this package. The following more-detailed instructions are generic; see the 'README' file for instructions specific to this package. Some packages provide this 'INSTALL' file but do not implement all of the features documented below. The lack of an optional feature in a given package is not necessarily a bug. More recommendations for GNU packages can be found in *note Makefile Conventions: (standards)Makefile Conventions. The 'configure' shell script attempts to guess correct values for various system-dependent variables used during compilation. It uses those values to create a 'Makefile' in each directory of the package. It may also create one or more '.h' files containing system-dependent definitions. Finally, it creates a shell script 'config.status' that you can run in the future to recreate the current configuration, and a file 'config.log' containing compiler output (useful mainly for debugging 'configure'). It can also use an optional file (typically called 'config.cache' and enabled with '--cache-file=config.cache' or simply '-C') that saves the results of its tests to speed up reconfiguring. Caching is disabled by default to prevent problems with accidental use of stale cache files. If you need to do unusual things to compile the package, please try to figure out how 'configure' could check whether to do them, and mail diffs or instructions to the address given in the 'README' so they can be considered for the next release. If you are using the cache, and at some point 'config.cache' contains results you don't want to keep, you may remove or edit it. The file 'configure.ac' (or 'configure.in') is used to create 'configure' by a program called 'autoconf'. You need 'configure.ac' if you want to change it or regenerate 'configure' using a newer version of 'autoconf'. The simplest way to compile this package is: 1. 'cd' to the directory containing the package's source code and type './configure' to configure the package for your system. Running 'configure' might take a while. While running, it prints some messages telling which features it is checking for. 2. Type 'make' to compile the package. 3. Optionally, type 'make check' to run any self-tests that come with the package, generally using the just-built uninstalled binaries. 4. Type 'make install' to install the programs and any data files and documentation. When installing into a prefix owned by root, it is recommended that the package be configured and built as a regular user, and only the 'make install' phase executed with root privileges. 5. Optionally, type 'make installcheck' to repeat any self-tests, but this time using the binaries in their final installed location. This target does not install anything. Running this target as a regular user, particularly if the prior 'make install' required root privileges, verifies that the installation completed correctly. 6. You can remove the program binaries and object files from the source code directory by typing 'make clean'. To also remove the files that 'configure' created (so you can compile the package for a different kind of computer), type 'make distclean'. There is also a 'make maintainer-clean' target, but that is intended mainly for the package's developers. If you use it, you may have to get all sorts of other programs in order to regenerate files that came with the distribution. 7. Often, you can also type 'make uninstall' to remove the installed files again. In practice, not all packages have tested that uninstallation works correctly, even though it is required by the GNU Coding Standards. 8. Some packages, particularly those that use Automake, provide `make distcheck', which can by used by developers to test that all other targets like 'make install' and 'make uninstall' work correctly. This target is generally not run by end users. Compilers and Options ===================== Some systems require unusual options for compilation or linking that the 'configure' script does not know about. Run './configure --help' for details on some of the pertinent environment variables. You can give 'configure' initial values for configuration parameters by setting variables in the command line or in the environment. Here is an example: ./configure CC=c99 CFLAGS=-g LIBS=-lposix *Note Defining Variables::, for more details. Compiling For Multiple Architectures ==================================== You can compile the package for more than one kind of computer at the same time, by placing the object files for each architecture in their own directory. To do this, you can use GNU 'make'. 'cd' to the directory where you want the object files and executables to go and run the 'configure' script. 'configure' automatically checks for the source code in the directory that 'configure' is in and in '..'. This is known as a "VPATH" build. With a non-GNU 'make', it is safer to compile the package for one architecture at a time in the source code directory. After you have installed the package for one architecture, use 'make distclean' before reconfiguring for another architecture. On MacOS X 10.5 and later systems, you can create libraries and executables that work on multiple system types--known as "fat" or "universal" binaries--by specifying multiple '-arch' options to the compiler but only a single '-arch' option to the preprocessor. Like this: ./configure CC="gcc -arch i386 -arch x86_64 -arch ppc -arch ppc64" \ CXX="g++ -arch i386 -arch x86_64 -arch ppc -arch ppc64" \ CPP="gcc -E" CXXCPP="g++ -E" This is not guaranteed to produce working output in all cases, you may have to build one architecture at a time and combine the results using the 'lipo' tool if you have problems. Installation Names ================== By default, 'make install' installs the package's commands under '/usr/local/bin', include files under '/usr/local/include', etc. You can specify an installation prefix other than '/usr/local' by giving 'configure' the option '--prefix=PREFIX', where PREFIX must be an absolute file name. You can specify separate installation prefixes for architecture-specific files and architecture-independent files. If you pass the option '--exec-prefix=PREFIX' to 'configure', the package uses PREFIX as the prefix for installing programs and libraries. Documentation and other data files still use the regular prefix. In addition, if you use an unusual directory layout you can give options like '--bindir=DIR' to specify different values for particular kinds of files. Run 'configure --help' for a list of the directories you can set and what kinds of files go in them. In general, the default for these options is expressed in terms of '${prefix}', so that specifying just '--prefix' will affect all of the other directory specifications that were not explicitly provided. The most portable way to affect installation locations is to pass the correct locations to 'configure'; however, many packages provide one or both of the following shortcuts of passing variable assignments to the 'make install' command line to change installation locations without having to reconfigure or recompile. The first method involves providing an override variable for each affected directory. For example, `make install prefix=/alternate/directory' will choose an alternate location for all directory configuration variables that were expressed in terms of '${prefix}'. Any directories that were specified during 'configure', but not in terms of '${prefix}', must each be overridden at install time for the entire installation to be relocated. The approach of makefile variable overrides for each directory variable is required by the GNU Coding Standards, and ideally causes no recompilation. However, some platforms have known limitations with the semantics of shared libraries that end up requiring recompilation when using this method, particularly noticeable in packages that use GNU Libtool. The second method involves providing the 'DESTDIR' variable. For example, 'make install DESTDIR=/alternate/directory' will prepend '/alternate/directory' before all installation names. The approach of 'DESTDIR' overrides is not required by the GNU Coding Standards, and does not work on platforms that have drive letters. On the other hand, it does better at avoiding recompilation issues, and works well even when some directory options were not specified in terms of '${prefix}' at 'configure' time. Optional Features ================= If the package supports it, you can cause programs to be installed with an extra prefix or suffix on their names by giving 'configure' the option '--program-prefix=PREFIX' or '--program-suffix=SUFFIX'. Some packages pay attention to '--enable-FEATURE' options to 'configure', where FEATURE indicates an optional part of the package. They may also pay attention to '--with-PACKAGE' options, where PACKAGE is something like 'gnu-as' or 'x' (for the X Window System). The 'README' should mention any '--enable-' and '--with-' options that the package recognizes. For packages that use the X Window System, 'configure' can usually find the X include and library files automatically, but if it doesn't, you can use the 'configure' options '--x-includes=DIR' and '--x-libraries=DIR' to specify their locations. Some packages offer the ability to configure how verbose the execution of 'make' will be. For these packages, running `./configure --enable-silent-rules' sets the default to minimal output, which can be overridden with 'make V=1'; while running `./configure --disable-silent-rules' sets the default to verbose, which can be overridden with 'make V=0'. Particular systems ================== On HP-UX, the default C compiler is not ANSI C compatible. If GNU CC is not installed, it is recommended to use the following options in order to use an ANSI C compiler: ./configure CC="cc -Ae -D_XOPEN_SOURCE=500" and if that doesn't work, install pre-built binaries of GCC for HP-UX. HP-UX 'make' updates targets which have the same time stamps as their prerequisites, which makes it generally unusable when shipped generated files such as 'configure' are involved. Use GNU 'make' instead. On OSF/1 a.k.a. Tru64, some versions of the default C compiler cannot parse its '' header file. The option '-nodtk' can be used as a workaround. If GNU CC is not installed, it is therefore recommended to try ./configure CC="cc" and if that doesn't work, try ./configure CC="cc -nodtk" On Solaris, don't put '/usr/ucb' early in your 'PATH'. This directory contains several dysfunctional programs; working variants of these programs are available in '/usr/bin'. So, if you need '/usr/ucb' in your 'PATH', put it _after_ '/usr/bin'. On Haiku, software installed for all users goes in '/boot/common', not '/usr/local'. It is recommended to use the following options: ./configure --prefix=/boot/common Specifying the System Type ========================== There may be some features 'configure' cannot figure out automatically, but needs to determine by the type of machine the package will run on. Usually, assuming the package is built to be run on the _same_ architectures, 'configure' can figure that out, but if it prints a message saying it cannot guess the machine type, give it the '--build=TYPE' option. TYPE can either be a short name for the system type, such as 'sun4', or a canonical name which has the form: CPU-COMPANY-SYSTEM where SYSTEM can have one of these forms: OS KERNEL-OS See the file 'config.sub' for the possible values of each field. If 'config.sub' isn't included in this package, then this package doesn't need to know the machine type. If you are _building_ compiler tools for cross-compiling, you should use the option '--target=TYPE' to select the type of system they will produce code for. If you want to _use_ a cross compiler, that generates code for a platform different from the build platform, you should specify the "host" platform (i.e., that on which the generated programs will eventually be run) with '--host=TYPE'. Sharing Defaults ================ If you want to set default values for 'configure' scripts to share, you can create a site shell script called 'config.site' that gives default values for variables like 'CC', 'cache_file', and 'prefix'. 'configure' looks for 'PREFIX/share/config.site' if it exists, then 'PREFIX/etc/config.site' if it exists. Or, you can set the 'CONFIG_SITE' environment variable to the location of the site script. A warning: not all 'configure' scripts look for a site script. Defining Variables ================== Variables not defined in a site shell script can be set in the environment passed to 'configure'. However, some packages may run configure again during the build, and the customized values of these variables may be lost. In order to avoid this problem, you should set them in the 'configure' command line, using 'VAR=value'. For example: ./configure CC=/usr/local2/bin/gcc causes the specified 'gcc' to be used as the C compiler (unless it is overridden in the site shell script). Unfortunately, this technique does not work for 'CONFIG_SHELL' due to an Autoconf limitation. Until the limitation is lifted, you can use this workaround: CONFIG_SHELL=/bin/bash ./configure CONFIG_SHELL=/bin/bash 'configure' Invocation ====================== 'configure' recognizes the following options to control how it operates. '--help' '-h' Print a summary of all of the options to 'configure', and exit. '--help=short' '--help=recursive' Print a summary of the options unique to this package's 'configure', and exit. The 'short' variant lists options used only in the top level, while the 'recursive' variant lists options also present in any nested packages. '--version' '-V' Print the version of Autoconf used to generate the 'configure' script, and exit. '--cache-file=FILE' Enable the cache: use and save the results of the tests in FILE, traditionally 'config.cache'. FILE defaults to '/dev/null' to disable caching. '--config-cache' '-C' Alias for '--cache-file=config.cache'. '--quiet' '--silent' '-q' Do not print messages saying which checks are being made. To suppress all normal output, redirect it to '/dev/null' (any error messages will still be shown). '--srcdir=DIR' Look for the package's source code in directory DIR. Usually 'configure' can determine that directory automatically. '--prefix=DIR' Use DIR as the installation prefix. *note Installation Names:: for more details, including other options available for fine-tuning the installation locations. '--no-create' '-n' Run the configure checks, but stop before creating any output files. 'configure' also accepts some other, not widely useful, options. Run 'configure --help' for more details. ocl-icd-2.3.3/Makefile.am000066400000000000000000000145641477331540600151110ustar00rootroot00000000000000 ACLOCAL_AMFLAGS = -I m4 SUBDIRS = . doc tests RUBY=ruby AM_CPPFLAGS = -Wall @AM_CPPFLAGS@ pkgconfigdir = $(libdir)/pkgconfig pkgconfig_DATA= OpenCL.pc ocl-icd.pc EXTRA_DIST=icd_generator.rb ocl_interface.yaml bootstrap \ $(TESTFILES) khronos-headers ################################################################## # Main OpenCL ICD Loader library lib_LTLIBRARIES = libOpenCL.la nodist_include_HEADERS = ocl_icd.h pkgexampledir = $(docdir)/examples pkgexample_DATA = ocl_icd_bindings.c FILES_FROM_DATABASE = ocl_icd.h ocl_icd_loader_gen.h \ ocl_icd_loader_gen.c ocl_icd_bindings.c \ ocl_icd_loader_gen.map BUILT_SOURCES = $(FILES_FROM_DATABASE) CLEANFILES = $(FILES_FROM_DATABASE) stamp-generator if UPDATE_DATABASE use_system_headers=--system-headers else use_system_headers= endif # Generate sources and headers from the database stamp-generator: ocl_interface.yaml $(FILES_FROM_DATABASE): stamp-generator stamp-generator: icd_generator.rb $(RUBY) $< --mode database --database $(srcdir)/ocl_interface.yaml \ $(use_system_headers) echo "timestamp" > $@ # ignore the warning in OpenCL headers when using old interface libOpenCL_la_CFLAGS= $(NO_DEPRECATED_DECLARATIONS_FLAGS) \ $(AM_CFLAGS) $(PTHREAD_CFLAGS) \ -DCL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES \ -DETC_OPENCL_VENDORS=\"@OCL_ICD_VENDORDIR@\" \ -DETC_OPENCL_LAYERS=\"@OCL_ICD_LAYERDIR@\" libOpenCL_la_SOURCES = ocl_icd_loader.c ocl_icd_loader.h ocl_icd_debug.h nodist_libOpenCL_la_SOURCES = ocl_icd_loader_gen.c ocl_icd.h libOpenCL_la_LDFLAGS = -version-info 1:0:0 $(PTHREAD_CFLAGS) libOpenCL_la_LIBADD = $(PTHREAD_LIBS) if USE_MAP libOpenCL_la_LDFLAGS += -Wl,--version-script,ocl_icd_loader_gen.map libOpenCL_la_DEPENDS = ocl_icd_loader_gen.map endif #################################### # A utility to list loaded layers bin_PROGRAMS = cllayerinfo cllayerinfo_SOURCES = cllayerinfo.c $(libOpenCL_la_SOURCES) nodist_cllayerinfo_SOURCES = $(nodist_libOpenCL_la_SOURCES) cllayerinfo_CFLAGS = -DCLLAYERINFO $(libOpenCL_la_CFLAGS) cllayerinfo_LDFLAGS = $(PTHREAD_CFLAGS) $(PTHREAD_LIBS) #################################### # A very small program test check_PROGRAMS=ocl_test ocl_test_icdl ocl_test_SOURCES = ocl_test.c ocl_test_LDADD = libOpenCL.la ocl_test_icdl_SOURCES = ocl_test_icdl.c ocl_test_icdl_LDADD = libOpenCL.la check_DATA = vendors/dummycl.icd vendors/dummycl2.icd vendors/dummycl-noext.icd CLEANFILES += vendors/dummycl.icd vendors/dummycl2.icd vendors/dummycl-noext.icd vendors/dummycl.icd: $(mkdir_p) vendors echo "$(CURDIR)/.libs/libdummycl.so" > $@ vendors/dummycl2.icd: $(mkdir_p) vendors echo "$(CURDIR)/.libs/libdummycl2.so" > $@ vendors/dummycl-noext.icd: $(MKDIR_P) vendors echo "$(CURDIR)/.libs/libdummycl-noext.so" > $@ clean-local: mostlyclean-generic clean-generic -rmdir vendors ################################################################## # dummy OpenCL ICD FILES_FROM_GENERATOR = run_dummy_icd_gen.c run_dummy_icd_weak_gen.c \ libdummy_icd_gen.c libdummy_icd_gen.h dummy_icd_layer_gen.c BUILT_SOURCES += $(FILES_FROM_GENERATOR) CLEANFILES += $(FILES_FROM_GENERATOR) stamp-generator-dummy # Generate sources and headers from OpenCL installed headers $(FILES_FROM_GENERATOR): stamp-generator-dummy stamp-generator-dummy: icd_generator.rb stamp-generator-dummy: icd_generator.rb $(RUBY) $< --mode generate --database $(srcdir)/ocl_interface.yaml echo "timestamp" > $@ # noinst_LTLIBRARIES would be the correct thing but then libtool # only built non shared version :-( So, declaring the libs as # pkglib_LTLIBRARIES and using an install hook to remove them. pkglib_LTLIBRARIES = libdummycl.la libdummycl2.la libdummycl-noext.la libdummylayer.la install-exec-hook:: $(RM) -r $(DESTDIR)$(pkglibdir) libdummycl_la_SOURCES = libdummy_icd.c libdummy_icd.h nodist_libdummycl_la_SOURCES = libdummy_icd_gen.c libdummy_icd_gen.h libdummycl_la_LDFLAGS = -module libdummycl_noext_la_SOURCES = $(libdummycl_la_SOURCES) nodist_libdummycl_noext_la_SOURCES = $(nodist_libdummycl_la_SOURCES) libdummycl_noext_la_LDFLAGS = -module libdummycl_noext_la_CPPFLAGS = $(AM_CPPFLAGS) -DICD_WITHOUT_EXTENSION libdummycl2_la_SOURCES = $(libdummycl_la_SOURCES) nodist_libdummycl2_la_SOURCES = $(nodist_libdummycl_la_SOURCES) libdummycl2_la_LDFLAGS = -module libdummycl2_la_CPPFLAGS = $(AM_CPPFLAGS) -DICD_SUFFIX=\"2\" nodist_libdummylayer_la_SOURCES = dummy_icd_layer_gen.c libdummylayer_la_LDFLAGS = -module noinst_PROGRAMS=run_dummy_icd_through_our_ICDL run_dummy_icd_through_our_ICDL_SOURCES = run_dummy_icd.c nodist_run_dummy_icd_through_our_ICDL_SOURCES = \ run_dummy_icd_gen.c run_dummy_icd_weak_gen.c # ignore the warning in OpenCL headers when using old interface run_dummy_icd_through_our_ICDL_CFLAGS= $(NO_DEPRECATED_DECLARATIONS_FLAGS) $(AM_CFLAGS) # we want to link to our implementation here run_dummy_icd_through_our_ICDL_LDADD = libOpenCL.la # run_dummy_icd_through_our_ICDL_CPPFLAGS = $(AM_CPPFLAGS) -DOCL_ICD_PRINT_EXPECTED ################################################################## # rules to update the database from an already installed ICD Loader if UPDATE_DATABASE noinst_PROGRAMS += run_dummy_icd run_dummy_icd_SOURCES = \ $(run_dummy_icd_through_our_ICDL_SOURCES) nodist_run_dummy_icd_SOURCES = \ $(nodist_run_dummy_icd_through_our_ICDL_SOURCES) run_dummy_icd_CFLAGS= \ $(run_dummy_icd_through_our_ICDL_CFLAGS) # we do not want to link to our implementation here run_dummy_icd_LDADD = -lOpenCL run_dummy_icd_LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@ # run the test program and update the database run_dummy_icd_output.yaml: run_dummy_icd install_test_lib libdummycl.la "$$(dirname $<)/$$(basename $<)" > $@ @if grep -v -E '^(---|([0-9]* *: .*))$$' $@ ; then \ echo "Invalid $@ file, trying to fix it" ; \ grep -E '^(---|([0-9]* *: .*))$$' $@ > $@.fix ;\ mv $@.fix $@ ;\ fi CLEANFILES += run_dummy_output.yaml .PHONY: update-database update-database: icd_generator.rb run_dummy_icd_output.yaml $(RUBY) $< --mode update-database \ --database $(srcdir)/ocl_interface.yaml \ --input run_dummy_icd_output.yaml .PHONY: install_test_lib uninstall_test_lib install_test_lib: sudo bash -c 'echo "$(CURDIR)/.libs/libdummycl.so" > /etc/OpenCL/vendors/dummycl.icd' uninstall_test_lib: sudo rm -f /etc/OpenCL/vendors/dummycl.icd else .PHONY: update-database update-database: @echo You need to reconfigure this software with --enable-update-database @exit 1 endif ################################################################## ocl-icd-2.3.3/NEWS000066400000000000000000000325751477331540600135560ustar00rootroot00000000000000Version 2.3.3 ============= Brice Videau (1): Add support for cl_khr_icd 2.0.0 specification Version 2.3.2 ============= Brice Videau (7): Add support for system layers Implement published clGetICDLoaderInfoOCLICD extension Define CL_NO_NON_DISPATCH_EXTENSION_PROTOTYPES for compatibility with recent headers Updated OpenCL Headers ot 2023.04.17 Remove use of __builtin_expect in layer dispatch Updated pkg-config to depend on OpenCL-Headers.pc Add cllayerinfo tool Version 2.3.1 ============= Brice Videau (3): Updated OpenCL Headers Add support for MacOS Add CI through GitHub Actions Version 2.3.0 ============= Vincent Danjean (1): Fixed typo in manpage Brice Videau (3): Change OCL_ICD_LAYERS to OPENCL_LAYERS to conform to specification Updated layer support around official CL/cl_layer.h Updated OpenCL Headers Version 2.2.14 ============== Brice Videau (1): Added experimental support for layers Version 2.2.13 ============== Brice Videau (9): Removed warnings and use uniform warning suppression Switched Khornos Headers to OpenCL3.0 Added OpenCL 3.0 support Updated copyright Fix warning in gcc10 Updated loader and headers to support clSetContextDestructorCallback. Call clGetDeviceIDs directly through the dispatch table Updated NEWS Release 2.2.13 Sergei Trofimovich (1): icd_generator.rb: fix build failure against gcc-10 Vincent Danjean (2): Fix typo in manpage Fix typo in doc Version 2.2.12 ============== Brice Videau (2): Switched khronos headers to OpenCL 2.2. Added OpenCL 2.2 support. Vincent Danjean (4): Merge remote-tracking branch 'origin/master' Add instructions about bootstrap in INSTALL file Release 2.2.12 Version 2.2.11 ============== Andreas Kloeckner (3): Add autoconf option for custom vendors .icd path Make vendordir relative to Hack the docs to reflect configured vendordir Vincent Danjean (8): Revert "By default, use platforme specific clGetPlatformInfo" Do not deference the plateform structure before checking it is an ICD Cleanup --enable-custom-vendordir usage [doc] ensure that files are correctly distributed and/or cleaned up [doc] improve doc [build] add notice message about what is choosen Merge branch 'rel-vendor' Release 2.2.11 Version 2.2.10 ============== Giuseppe Bilotta (2): Suppress warning due to shadowed variable name Static-const-ify ICD loader info strings Martin Kelly (2): Typo fix Fallback to dispatch table for clGetPlatformInfo Vincent Danjean (3): Merge pull request #2 from surround-io/master By default, use platforme specific clGetPlatformInfo Release 2.2.10 Version 2.2.9 ============= Brice Videau (1): Update clGetICDLoaderInfoOCLICD to report version 2.1. Vincent Danjean (3): Report the correct supported OpenCL version when asked Add support for OPENCL_VENDOR_PATH envvar Release 2.2.9 Version 2.2.8 ============= Brice Videau (10): Added missing EGL entries. Added missing clGetKernelSubGroupInfoKHR. Fixed indentation. Added OpenCL 2.1 as comments. Switched khronos headers to OpenCL 2.1. Fixed typo in clEnqueueAcquireEGLObjectsKHR definition. CL/cl_egl.h is needed to build EGL interfaces. OpenCL headers needlessly include EGL headers. ICD should be compliant regarding extensions. Order for OpenCL 2.1 is finally known. Vincent Danjean (10): Explicitly set the revision date in the documentation cleanup doc [test] avoid external problems in tests Use internal symbols to avoid conflict with loaded ICD Update copyright notices Remove 2.0 OpenCL headers Avoid to hardcode at several place the required OpenCL headers version improve clGetExtensionFunctionAddress{,ForPlatform} Fix guards in ocl_icd.h Release 2.2.8 (support OpenCL 2.1) Version 2.2.7 ============= Vincent Danjean (2): Also use real prototype in weak test functions New release Version 2.2.6 ============= Vincent Danjean (4): Fix and improve testsuite allows to avoid the platform sort and extends the testsuite Improve documentation (OCL_ICD_PLATFORM_SORT and OCL_ICD_DEFAULT_PLATFORM) Release 2.2.6 Version 2.2.5 ============= Giuseppe Bilotta (5): Fix a few typos Whitespace cleanup Remove useless vendor_icd.first_platform Count GPU, CPU and ALL devices on newly inserted platforms Sort platforms by number of GPU, CPU and ALL devices Vincent Danjean (4): Sort platforms in one pass Correctly handle clGetDeviceIDs in generator and tests [BUG] call the function when the return type is void Release 2.2.5 Version 2.2.4 ============= Brice Videau (1): Consistency. Vincent Danjean (4): Avoid using system-wide vendors files at test time avoid loading ICD at library init time Improve tests Fix initialization in case of default platform use Release 2.2.4 Version 2.2.3 ============= Vincent Danjean (2): Fix numbers in unknown members of dispatch table to avoid to reuse one Release 2.2.3 Version 2.2.2 ============= Vincent Danjean (3): Avoid warnings with 2.0 OpenCL headers when using 1.2 deprecated functions Avoid using types not supported by OpenCL headers in ocl_icd.h Release 2.2.2 Version 2.2.1 ============= Vincent Danjean (2): add official Khronos OpenCL headers into repo Release 2.2.1 Version 2.2.0 ============= Aaron Watry (2): Fix directory resource leak Don't read past the potential end of the lib_path string Brice Videau (4): Added OpenCL 2.0 functions. Hopefully at the right position (to confirm). Generator can process 2.0 functions. Added up to date headers package. Commented 2.0 OpenCL API. Vincent Danjean (5): Remove -Werror for AM_CPPFLAGS by default Interface 2.0 Bug fix in code path rarely used Bump versions Release 2.2.0 Version 2.1.3 ============= Brice Videau (3): Moved some declarations to the header as they are needed in the generated part now. If we have no valid platforms non can be valid. In case a NULL platform is passed to the loader, the default platform is selected if it exists and is valid. Vincent Danjean (5): Rewrote initialization comments All generated file ends with "_gen" suffix (but installed once) [build] add tests for default platform selection Refactor code for selection of default platform Release 2.1.3 Version 2.1.2 ============= Brice Videau (5): Indentation fix Check for platform validity. Could be improved. Check cl_platform_id in clCreateContext and clCreateContextFromType Code cleanup. Added platform checking for clGetGLContextInfoKHR. Vincent Danjean (2): Refactor code and compilation fix in clGetGLContextInfoKHR Release 2.1.2 Version 2.1.1 ============= Vincent Danjean (2): Fix missing NULL argument handling in clCreateContext Release 2.1.1 Version 2.1.0 ============= Brice Videau (1): Added NULL pointers handling, should not segfault anymore on NULL pointer. Vincent Danjean (2): Refactor generated code Release 2.1.0 Version 2.0.4 ============= Brice Videau (1): Include guard for ocl_icd.h Vincent Danjean (3): Fix configure.ac for automake 1.13 By default, show all compile commands Release 2.0.4 Version 2.0.3 ============= Brice Videau (1): Small potential bugfix and hopefull norm interpretation. Vincent Danjean (2): Fix PATH for "make installcheck" Release 2.0.3 Version 2.0.2 ============= Brice Videau (3): Added windows specific functions to the table fix bug when loading a correct icd *after* rejecting one New version Vincent Danjean (10): Fix bug for dumping the internal ICD structure clGetExtensionFunctionAddress should return only extensions cleanup code Implement clGetICDLoaderInfoOCLICD extension with a test case [build] lower requirement on autoconf Default platform is now specified Add clTerminateContextKHR in testsuite cleanup icd_generator refactor icd_generator icd_generator: still cleanup Update NEWS file Version 2.0.1 ============= Vincent Danjean (4): [doc] fix typo found by lintian [doc] remove unused synopsis [doc] fix another typo found by lintian New release Version 2.0 ============= Brice Videau (1): Found entry 92, clCreateEventFromGLsyncKHR. Vincent Danjean (16): Check the avaibility of OpenCL headers (version 1.2) include stdlib.h for getenv and atoi Allow OCL_ICD_VENDORS to directly provide the ICD library name to load Migrate to autotest Update testsuite with the new entry Fix re-entrancy in DEBUG mode while initializing. Fix log with strange behavior of clGetExtensionFunctionAddressForPlatform on Intel Build test programs before entering tests/ subdir fix 'make distcheck' Force order in output of check programs Improve OCL_ICD_VENDORS envvar Cleanup and fix debug ifdef Workaround for a bug in intel ICD with optimus Add a test for the Intel workaround Add documentation, mainly for envvar New release Version 1.5 ============= Brice Videau (1): Code factoring and race condition reduction. Vincent Danjean (4): Merge branch 'master' Fix race in initialization on pthread programs Make initialisation more robust New release Version 1.4 ============= Vincent Danjean (9): [debug] improve platform dump [build] cleanup code [build] ignore warnings of OpenCL headers even with -Werror [build] avoid deprecated function warning in debug [fix] Use OpenCL supported version as version in OpenCL.pc [bug fix] Initialize the library in all possible first functions [bug fix] clCreateContextFromType can have a NULL properties [debug] More debug info New release Version 1.3 ============= Brice Videau (1): Added -Wno-deprecated-declarations options to compile files that need it. Vincent Danjean (5): Fix compilation when updating database Merge branch 'master' of git+ssh://scm.forge.imag.fr/scmrepos/git/ocl-icd/ocl-icd Add a pkg-config file for ICD libraries Check if compiler support flags to disable expected warnings New release Version 1.2.1 ============= Vincent Danjean (4): Correctly remove created directories Do not distribute built sources Distribute all required files New release without autogenerated files Version 1.2 ============= Brice Videau (1): Added clGetGLContextInfoKHR to the loader. Vincent Danjean (11): Fix Changelog Add a easy way to disable DEBUG in Makefile Improve debug mode Add support for using alternate vendors configuration directory Swich to autotools Correct iteration in vendors/ directory Cleanup debug, refactor libdummycl Merge remote-tracking branch 'origin/master' cleanup code and add additionnal tests Whitelist known missing functions in ICD Loader New release Version 1.1 ============= Vincent Danjean (10): Add missing include in ocl_icd_test.c Format YAML output ourself Rename files and cleanup includes Cleanup again Add visibility("hidden") for all but public symbols Rewrite ICD loader Cleanup debug Do not look for *EXT or *KHR functions by name Find a new entry manually (74) and another one (92) suspected Bump version to 1.1 Version 1.0.1 ============= Vincent Danjean (2): Correctly detect no platforms when no /etc/OpenCL/vendors directory exists New version Version 1.0 =========== Vincent Danjean (6): Add a message in ocl_icd_test when no plateform is found Cleanup and comment the Makefile cleanup ocl_icd.h Generate and use a map symbol file Release 1.0 Real release 1.0 (changelog updated) Brice Videau (5): Copyright change. Added clUnloadCompiler at its most propable place in the table : 31. Added clGetExtensionFunctionAddress at its most probable place in the table : 65. RTLD_DEEPBIND seemed to cause problems with intelocl and BigDFT. Added version and symbol association. Version 1.0 beta2 ================= Vincent Danjean (14): Rewrite Makefile cleanup Makefile, add support for install with DESTDIR Add .gitignore file update Makefile Force sorted order in yaml file Add weak functions Fix problem with special functions Update database from OpenCL 1.2 headers and AMD implementation Cleanup clean/distclean Makefile rules force deep binding so that OpenCL implementation use their own functions Add 'install', 'dist', 'distcheck' targets in Makefile Add myself in copyright Fix soname release 1.0 beta2 Brice Videau (9): First version Added option to generate from database. Added License and bugfixes. Clean up of Makefile. (Still work to do). Added a clGetPlatformInfo template in generated bindings. Bugfix... Bugfix. Added README. In order database. Fixed typo in Makefile ocl-icd-2.3.3/OpenCL.pc.in000066400000000000000000000003741477331540600151200ustar00rootroot00000000000000prefix=@prefix@ exec_prefix=@exec_prefix@ libdir=@libdir@ includedir=@includedir@ Name: OpenCL Description: Open Computing Language generic Installable Client Driver Loader Requires: OpenCL-Headers Version: @OPENCL_VERSION@ Libs: -L${libdir} -lOpenCL ocl-icd-2.3.3/README000066400000000000000000000025531477331540600137300ustar00rootroot00000000000000This package aims at creating an Open Source alternative to vendor specific OpenCL ICD loaders. The main difficulties to create such software is that the order of function pointers in a structure is not publicy available. This software maintains a YAML database of all known and guessed entries. If the configure script is called with --enable-update-database, then: - a dummy OpenCL implementation using available headers on the system is created - this dummy OpenCL implementation is installed system-wide (root access needed) with the file dummy.icd in /etc/OpenCL/vendors/ - a test program then calls every function defined in the headers and thus obtains the function mapping inside the demultiplexer So, if an other OpenCL ICD loader is installed on the system, this allows us to discover the mapping of new entries in the structure, entries that are then recoreded in the YAML database. Of course, if the currently installed OpenCL ICD loader is this one, there wont be any problems but no new mapping will be discovered. This package also delivers a skeleton of bindings to incorporate inside an OpenCL implementation to give it ICD functionalities. Main Make targets: all/check/install/...: builds the library and bindings from database update-database: adds new functions to the database from the currently installed OpenCL ICD Loader. Needs root permission. ocl-icd-2.3.3/bootstrap000077500000000000000000000060431477331540600150110ustar00rootroot00000000000000#!/bin/sh # vim:ts=4:sw=4 # Calls autotools to build configure script and Makefile.in. # Generated automatically using bootstrapper 0.2.1 # http://bootstrapper.sourceforge.net/ # # Copyright (C) 2002 Anthony Ventimiglia # # This bootstrap script is free software; you can redistribute # it and/or modify it under the terms of the GNU General Public # License as published by the Free Software Foundation; either # version 2 of the License, or (at your option) any later version. # # # Calls proper programs to create configure script and Makefile.in files. # if run with the --clean option, bootstrap removes files it generates. To # clean all autogenerated files (eg: for cvs imports) first run # make distclean, then bootstrap --clean # see bootstrapper(1) for more infor set -e if test x"$1" = x"--help"; then echo "$0: automatic bootstrapping utility for GNU Autotools" echo " cleans up old autogenerated files and runs autoconf," echo " automake and aclocal on local directory" echo echo " --clean clean up auto-generated files without" echo " creating new scripts" echo exit 0 fi export ACLOCAL="aclocal" export AUTOCONF="autoconf" export AUTOHEADER="autoheader" export AUTOMAKE="automake" CONFIG_AUX_DIR="build-aux" #LIBTOOLIZE="/usr/bin/libtoolize --force" #LIBTOOLIZE_FILES="config.sub ltmain.sh config.guess" #LIBTOOLIZE="libtoolize --copy" #LIBTOOLIZE="glibtoolize --copy" CLEAN_BASE_DIRS="autom4te.cache" CLEAN_BASE_FILES="configure" CLEAN_BASE_FILES="$CLEAN_BASE_FILES config.h.in config.h.in~" CLEAN_BASE_FILES="$CLEAN_BASE_FILES aclocal.m4 acinclude/libtool.m4 acinclude/ltoptions.m4" CLEAN_BASE_FILES="$CLEAN_BASE_FILES acinclude/ltversion.m4 acinclude/lt~obsolete.m4 acinclude/ltsugar.m4" CLEAN_AUX_FILES="config.guess compile depcomp mkinstalldirs libtool ltmain.sh missing config.sub install-sh mdate-sh texinfo.tex" RM="rm -v" SUBDIRS="$(sed -e '/Makefile/s,[[:space:]]*\([^[:space:]]*\)/\?Makefile,./\1,p;d' configure.ac)" if libtoolize --version >/dev/null 2>&1; then export LIBTOOLIZE="libtoolize --force" else # for non GNU OS export LIBTOOLIZE="glibtoolize --force" fi # These are files created by configure, so we'll always clean them for i in $ALWAYS_CLEAN; do test -f $i && \ $RM $i done if test x"$1" = x"--clean"; then # #Clean Files left by previous bootstrap run # if test -n "$CONFIG_AUX_DIR"; then CONFIG_AUX_DIR="$CONFIG_AUX_DIR/" fi # Clean directories in base directory for cf in $CLEAN_BASE_DIRS; do if test -d $cf ; then $RM -r $cf else echo "Skipping non existing directory '$cf'" fi done #Clean Automake generated Makefile.in files for i in $SUBDIRS; do test -f $i/Makefile.in && \ $RM $i/Makefile.in done # Clean files in base directory for cf in $CLEAN_BASE_FILES; do if test -f $cf ; then $RM $cf else echo "Skipping non existing file '$cf'" fi done # Clean files in aux directory for cf in $CLEAN_AUX_FILES; do cf="$CONFIG_AUX_DIR$cf" if test -f $cf ; then $RM $cf else echo "Skipping non existing file '$cf'" fi done else set -x autoreconf -vi -Wall "$@" set +x fi ocl-icd-2.3.3/cllayerinfo.c000066400000000000000000000034741477331540600155260ustar00rootroot00000000000000#include "ocl_icd_loader.h" #include #include #include #include int stdout_bak, stderr_bak; static inline int silence_fd(FILE *file, int fd) { int new_fd, fd_bak; fflush(file); fd_bak = dup(fd); new_fd = open("/dev/null", O_WRONLY); dup2(new_fd, fd); close(new_fd); return fd_bak; } static inline void restore_fd(FILE *file, int fd, int fd_bak) { fflush(file); dup2(fd_bak, fd); close(fd_bak); } static void silence_outputs(void) { stdout_bak = silence_fd(stdout, 1); stderr_bak = silence_fd(stderr, 2); } static void restore_outputs(void) { restore_fd(stdout, 1, stdout_bak); restore_fd(stderr, 2, stderr_bak); } void mute(void) { silence_outputs(); atexit(restore_outputs); } void unmute(void) { restore_outputs(); atexit(silence_outputs); } void print_layer_info(const struct layer_icd *layer) { cl_layer_api_version api_version = 0; clGetLayerInfo_fn layer_info_fn_ptr = (clGetLayerInfo_fn)layer->layer_info_fn_ptr; cl_int error = CL_SUCCESS; size_t sz; printf("%s:\n", layer->library_name); error = layer_info_fn_ptr(CL_LAYER_API_VERSION, sizeof(api_version), &api_version, NULL); if (error == CL_SUCCESS) printf("\tCL_LAYER_API_VERSION: %d\n", (int)api_version); error = layer_info_fn_ptr(CL_LAYER_NAME, 0, NULL, &sz); if (error == CL_SUCCESS) { char *name = (char *)malloc(sz); if (name) { error = layer_info_fn_ptr(CL_LAYER_NAME, sz, name, NULL); if (error == CL_SUCCESS) printf("\tCL_LAYER_NAME: %s\n", name); free(name); } } } int main (int argc, char *argv[]) { (void)argc; (void)argv; mute(); _initClIcd_no_inline(); unmute(); const struct layer_icd *layer = _first_layer; while (layer) { print_layer_info(layer); layer = layer->next_layer; } return 0; } ocl-icd-2.3.3/configure.ac000066400000000000000000000146201477331540600153340ustar00rootroot00000000000000# -*- Autoconf -*- # Process this file with autoconf to produce a configure script. # # Copyright (c) 2012-2020, Brice Videau # Copyright (c) 2012-2020, Vincent Danjean AC_PREREQ([2.67]) AC_INIT([OpenCL ICD Loader], [2.3.3], [ocl-icd-devel@lists.forge.imag.fr], [ocl-icd]) AC_CONFIG_SRCDIR([ocl_icd_loader.c]) AC_CONFIG_AUX_DIR([build-aux]) AC_CONFIG_HEADERS([config.h]) AC_CONFIG_MACRO_DIR([m4]) AC_CANONICAL_HOST case $host_os in *macos*) macos="yes" ;; *darwin*) macos="yes" ;; *) macos="no" ;; esac AM_INIT_AUTOMAKE([-Wall -Werror foreign 1.9 tar-pax check-news color-tests parallel-tests]) AMX_SILENT_RULES([AM_DEFAULT_VERBOSITY=1]) # AM_PROG_AR must be called before LT_INIT... AM_PROG_AR LT_INIT([disable-static]) AC_CONFIG_TESTDIR([tests], [.]) m4_define([REQ_OPENCL_VERSION],[3_0]) OPENCL_VERSION="m4_translit(REQ_OPENCL_VERSION, [_], [.])" AC_SUBST([OPENCL_VERSION]) AC_DEFINE_UNQUOTED([OCL_ICD_OPENCL_VERSION], ["$OPENCL_VERSION"], [supported OpenCL version]) # Checks for programs. AC_PROG_CC_C89 AC_PROG_INSTALL AC_PROG_LN_S AM_PROG_CC_C_O AC_PATH_PROG([ASCIIDOC], [asciidoc], []) AC_PATH_PROG([A2X], [a2x], []) AC_PATH_PROG([XMLTO], [xmlto], []) AS_IF([ test x"$ASCIIDOC" != x && \ test x"$A2X" != x && \ test x"$XMLTO" != x ], [ gen_doc=1 AC_MSG_NOTICE([generating documentation]) ], [ gen_doc=0 AC_MSG_NOTICE([documentation generation disabled]) ]) AM_CONDITIONAL([GEN_DOC], [ test x"$gen_doc" = x1 ]) # Checks for libraries. AC_CHECK_LIB([dl], [dlopen]) # Checks for header files. AC_CHECK_HEADERS([stdlib.h string.h]) cl_h=no case $host_os in darwin* ) AC_CHECK_HEADER([OpenCL/opencl.h],[cl_h=yes]) AC_CHECK_HEADERS([OpenCL/cl_layer.h]) ;; * ) AC_CHECK_HEADER([CL/opencl.h],[cl_h=yes]) AC_CHECK_HEADERS([CL/cl_layer.h]) ;; esac if test $cl_h = yes; then AC_MSG_CHECKING([whether OpenCL headers $OPENCL_VERSION are available]) AC_PREPROC_IFELSE([ AC_LANG_PROGRAM([[ #if defined(__APPLE__) || defined(__MACOSX) # include #else # include #endif #ifndef CL_VERSION_]REQ_OPENCL_VERSION[ # error Cannot find CL_VERSION_]REQ_OPENCL_VERSION[ symbol #endif ]], [[ ]])],[ AC_MSG_RESULT([yes]) ],[ AC_MSG_RESULT([no]) cl_h=no ]) fi # Checks for typedefs, structures, and compiler characteristics. AC_C_INLINE AC_TYPE_SIZE_T AC_C_CONST NO_DEPRECATED_DECLARATIONS_FLAGS= AX_CHECK_COMPILER_FLAGS([-Wno-deprecated-declarations], [NO_DEPRECATED_DECLARATIONS_FLAGS="-Wno-deprecated-declarations"]) AC_SUBST([NO_DEPRECATED_DECLARATIONS_FLAGS]) # Checks for library functions. AC_FUNC_MALLOC AC_FUNC_REALLOC AC_CHECK_FUNCS([strstr]) # --enable-pthread-once AC_ARG_ENABLE([pthread-once], [AS_HELP_STRING([--enable-pthread-once], [use pthread_once() to ensure correct initialisation without polling])], [pthread_once=$enableval], [pthread_once=no]) if test "$pthread_once" = yes ; then AX_PTHREAD([ AC_DEFINE([USE_PTHREAD], [1], [pthreads are available]) ], [ AC_MSG_ERROR([No pthread detected on this platform!]) ]) fi # --enable-official-khronos-headers AC_ARG_ENABLE([official-khronos-headers], [AS_HELP_STRING([--enable-official-khronos-headers], [use official Khronos OpenCL headers provided in the sources instead of OpenCL headers installed on the system])], [khronos_headers=$enableval], [khronos_headers=may]) AS_CASE([$cl_h,$khronos_headers], [no,no], [AC_MSG_ERROR([No $OPENCL_VERSION OpenCL headers available and --disable-official-khronos-headers used])], [no,*], [khronos_headers=yes], [yes,yes], [AC_MSG_WARN([Using internal copy of OpenCL headers as requested, even if they are available on the system])], [yes,*], [khronos_headers=no], [AC_MSG_ERROR([Internal error. Please, report this bug])]) if test $khronos_headers = no; then AC_MSG_NOTICE([using system OpenCL headers]) else AC_MSG_NOTICE([using internal copy of OpenCL headers]) AM_CPPFLAGS="$AM_CPPFLAGS -I\${abs_top_srcdir}/khronos-headers" AC_SUBST([AM_CPPFLAGS]) fi # --disable-debug AC_ARG_ENABLE([debug], [AS_HELP_STRING([--disable-debug], [remove debug and additionnal checks (default is included)])], [use_debug=$enableval], [use_debug=yes]) if test "x$use_debug" != xno ; then AC_DEFINE([DEBUG_OCL_ICD], [1], [Add DEBUG additionnal code]) fi # --enable-update-database AC_ARG_ENABLE([update-database], [AS_HELP_STRING([--enable-update-database], [update the YAML database from the currently installed ICD Loader and OpenCL headers (root access required)])], [update_database=$enableval], [update_database=no]) AM_CONDITIONAL([UPDATE_DATABASE], [test x"$update_database" != xno]) # --enable-custom-vendordir AC_ARG_ENABLE([custom-vendordir], [AS_HELP_STRING([--enable-custom-vendordir], [use the given directory instead of /etc/OpenCL/vendors to look for .icd files])], [AS_CASE(["$enableval"], [yes], [OCL_ICD_VENDORDIR="$sysconfdir/OpenCL/vendors"], [no], [OCL_ICD_VENDORDIR='/etc/OpenCL/vendors'], [OCL_ICD_VENDORDIR=$enableval])], [OCL_ICD_VENDORDIR=/etc/OpenCL/vendors]) AC_SUBST([OCL_ICD_VENDORDIR]) AS_IF([test x"$OCL_ICD_VENDORDIR" = x"/etc/OpenCL/vendors" ], [ AC_MSG_NOTICE([using the official default vendors directory ($OCL_ICD_VENDORDIR)]) ], [ AC_MSG_NOTICE([using an unofficial custom default vendors directory ($OCL_ICD_VENDORDIR)]) ]) # --enable-custom-layerdir AC_ARG_ENABLE([custom-layerdir], [AS_HELP_STRING([--enable-custom-layerdir], [use the given directory instead of /etc/OpenCL/layers to look for .lay files])], [AS_CASE(["$enableval"], [yes], [OCL_ICD_LAYERDIR="$sysconfdir/OpenCL/layers"], [no], [OCL_ICD_LAYERDIR='/etc/OpenCL/layers'], [OCL_ICD_LAYERDIR=$enableval])], [OCL_ICD_LAYERDIR=/etc/OpenCL/layers]) AC_SUBST([OCL_ICD_LAYERDIR]) AS_IF([test x"$OCL_ICD_LAYERDIR" = x"/etc/OpenCL/layers"], [ AC_MSG_NOTICE([using the official default layers directory ($OCL_ICD_LAYERDIR)]) ], [ AC_MSG_NOTICE([using an unofficial custom default layers directory ($OCL_ICD_LAYERDIR)]) ]) # always use versionned symbols (check required for MacOSX) if test "x$macos" == xyes ; then AM_CONDITIONAL([USE_MAP], [false]) else AM_CONDITIONAL([USE_MAP], [true]) fi AC_CONFIG_FILES([ Makefile doc/Makefile tests/Makefile OpenCL.pc ocl-icd.pc tests/atlocal ]) AC_OUTPUT ocl-icd-2.3.3/doc/000077500000000000000000000000001477331540600136105ustar00rootroot00000000000000ocl-icd-2.3.3/doc/Makefile.am000066400000000000000000000017441477331540600156520ustar00rootroot00000000000000 MAN7 = libOpenCL.7 libOpenCL.so.7 MAN_DOC = $(MAN7) MAN_TXT = libOpenCL.7.txt MAN_TXT_IN = libOpenCL.7.txt.in MAN_HTML = libOpenCL.html EXTRA_DIST = $(MAN_TXT_IN) if GEN_DOC htmldocdir=$(docdir)/html man_MANS = $(MAN_DOC) htmldoc_DATA = $(MAN_HTML) CLEANFILES = $(MAN_DOC) $(MAN_HTML) $(MAN_TXT) SUFFIXES=.html .7.txt .7 libOpenCL.7.txt: libOpenCL.7.txt.in Makefile $(AM_V_GEN)if [ "${OCL_ICD_VENDORDIR}" = '/etc/OpenCL/vendors' ]; then \ KEEP=OFFICIAL ; REMOVE=CUSTOM ; \ else \ KEEP=CUSTOM ; REMOVE=OFFICIAL ; \ fi && \ $(SED) \ -e 's|[@]OCL_ICD_VENDORDIR@|@OCL_ICD_VENDORDIR@|g' \ -e 's|[@]OCL_ICD_LAYERDIR@|@OCL_ICD_LAYERDIR@|g' \ -e "/^@@$$REMOVE: /d" \ -e "s/^@@$$KEEP: //" \ < "$<" > "$@" .7.txt.html: $(AM_V_GEN)$(ASCIIDOC) -d manpage -b xhtml11 -o$@ $< .7.txt.7: $(AM_V_GEN)$(A2X) --doctype manpage --format manpage \ --destination-dir=$(CURDIR) $< libOpenCL.so.7: libOpenCL.7 @: already create by a2x when generating libOpenCL.7 endif ocl-icd-2.3.3/doc/libOpenCL.7.txt.in000066400000000000000000000112741477331540600167370ustar00rootroot00000000000000libOpenCL(7) ============ Vincent Danjean :Author Initials: VD :revdate: 2015-06-08 :footer-style: revdate :toc: :icons: :numbered: NAME ---- libOpenCL, libOpenCL.so - OCL-ICD implementation of OpenCL ICD loader DESCRIPTION ----------- `libOpenCL.so` is the library linked by OpenCL programs. It does not contains any OpenCL implementation itself, but merely act as a dispatcher to real OpenCL implementations provided as OpenCL Installable Client Driver (ICD). An ICD loader should be able to load ICDs provided by any vendors. @@OFFICIAL: According to OpenCL specifications from Khronos (see [Khronos]), the @@CUSTOM: The ICD Loader looks for files into '`@OCL_ICD_VENDORDIR@`' directory and, for each file whose name ends with '`.icd`', the ICD Loader loads with **dlopen**(3) the shared library whose name is on the first line of the '`.icd`' file. @@CUSTOM: According to OpenCL specifications from Khronos (see @@CUSTOM: [Khronos]), the default path for this purpose is @@CUSTOM: '`/etc/OpenCL/vendors`', but this OCL-ICD version has been @@CUSTOM: configurated otherwise. Each shared library name in ".icd" files can have its path, or it can be a plain filename. In the latter case, the ICD shared library will be looked for into the standard dynamic library loader paths. ENVIRONMENT ------------- Some environment variables can be used modify the default behavior of libOpenCL. *OPENCL_VENDOR_PATH*:: This variable allows one to modify the default '`@OCL_ICD_VENDORDIR@`' path. It is compatible with some other ICD loaders (but not all of them, as the variable is not part of the standard). Note that *$OCL_ICD_VENDORS* (see below) is used in priority if defined and not empty. *OCL_ICD_VENDORS*:: This variable allows one to change the way ICD are searched on the system. Several cases are considered: a. if *$OCL_ICD_VENDORS* is a directory path, then this path replaces the "@OCL_ICD_VENDORDIR@" path in the standard behavior: the loader will use the '`.icd`' files in this directory; b. else, if *$OCL_ICD_VENDORS* ends with '`.icd`', libOpenCL.so will only load the ICD whose shared library name is wrote into the specified ".icd" file; + If there is no slashes into *$OCL_ICD_VENDORS*, libOpenCL.so will first try to use '`@OCL_ICD_VENDORDIR@/`'*$OCL_ICD_VENDORS* (or *$OPENCL_VENDOR_PATH*'`/`'*$OCL_ICD_VENDORS* if *OPENCL_VENDOR_PATH* is defined). If this fail or if there are shashes, it uses *$OCL_ICD_VENDORS* (as a relative or absolute file name path). c. else libOpenCL.so will try to load *$OCL_ICD_VENDORS* as the ICD shared library itself (i.e. to load it directly with **dlopen**(3)). *OPENCL_LAYERS*:: This variable allows one to specify a colon separated list of layers to load, specifying their path. *OPENCL_LAYER_PATH*:: This variable allows one to override the default system layer search path ('`@OCL_ICD_LAYERDIR@`'). *OCL_ICD_ASSUME_ICD_EXTENSION*:: If set to an non-empty value, contrary the Khronos specification, the loader will not check that the loaded ICDs declare the `cl_khr_icd` extension. It will also use the clGetPlatformInfo from the dispatch table if no such function is globally available. You may need to define this environment variable if you are using not (fully) compliant ICD, or if you are using the Intel ICD together with *optirun*(1). In the latter case, a bug into the Intel ICD will make the application crash. If set to the '`debug`' value, some additional messages will be printed in debug mode (see *OCL_ICD_DEBUG* below). *OCL_ICD_PLATFORM_SORT*:: Allows one to choose the way platforms are sorted when presented to programs through **clGetPlatformIDs**(3). Current provided algorithms are: * *devices*: first, list platforms that support most GPU, then most CPU then most accelerators. If *OCL_ICD_PLATFORM_SORT* is not set or set to an unknown value, this algorithm is used. * *none*: no sort is done and the order can change at each run. *OCL_ICD_DEFAULT_PLATFORM*:: Number of the platform to choose as default platform. Note that using this environment variable without ensuring the use of a sort algorithm for platforms is not really useful. *OCL_ICD_DEBUG*:: + -- If ocl-icd has been compiled with debug support, you can set this environment variable to a value where each bit display some kind of informations. Defined values are: * *1*: warnings (enabled by default if debug support is present and *OCL_ICD_DEBUG* is not set) * *2*: informative messages * *4*: entering/exiting for some OpenCL functions * *8*: dump of the internal structure of loaded ICDs *OCL_ICD_DEBUG* is mainly useful for ocl-icd development itself and/or for ICD development. -- SEE ALSO -------- https://www.khronos.org/registry/cl/[Khronos OpenCL registry website] ocl-icd-2.3.3/icd_generator.rb000066400000000000000000001154671477331540600162130ustar00rootroot00000000000000=begin Copyright (c) 2012-2020, Brice Videau Copyright (c) 2012-2020, Vincent Danjean All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. =end require 'yaml' module IcdGenerator $api_entries = {} $key_entries = {} $api_entries_array = [] $cl_objects = ["platform_id", "device_id", "context", "command_queue", "mem", "program", "kernel", "event", "sampler"] $know_entries = { 1 => "clGetPlatformInfo", 0 => "clGetPlatformIDs", 2 => "clGetDeviceIDs" } $use_name_in_test = { 1 => "clGetPlatformInfo", 0 => "clGetPlatformIDs", 2 => "clGetDeviceIDs" } # do not call these functions when trying to discover the mapping $forbidden_funcs = [ "clUnloadCompiler", # No parameters so no way to forward to an ICD, OpenCL 1.0 "clGetPlatformIDs", # Implemented directly within the ICD Loader, not forwarded to ICD ] # windows function to ignore when loading the database $windows_funcs = ["clGetDeviceIDsFromD3D10KHR", "clCreateFromD3D10BufferKHR", "clCreateFromD3D10Texture2DKHR", "clCreateFromD3D10Texture3DKHR", "clEnqueueAcquireD3D10ObjectsKHR", "clEnqueueReleaseD3D10ObjectsKHR", "clGetDeviceIDsFromD3D11KHR", "clCreateFromD3D11BufferKHR", "clCreateFromD3D11Texture2DKHR", "clCreateFromD3D11Texture3DKHR", "clEnqueueAcquireD3D11ObjectsKHR", "clEnqueueReleaseD3D11ObjectsKHR", "clGetDeviceIDsFromDX9MediaAdapterKHR", "clCreateFromDX9MediaSurfaceKHR", "clEnqueueAcquireDX9MediaSurfacesKHR", "clEnqueueReleaseDX9MediaSurfacesKHR"] # do not create weak functions for these ones in the discovering program $noweak_funcs = ["clGetExtensionFunctionAddress", "clGetPlatformIDs", "clGetPlatformInfo", "clGetGLContextInfoKHR", "clUnloadCompiler", "clCreateContext", "clCreateContextFromType", "clWaitForEvents"] # functions written specifically in the loader $specific_loader_funcs = ["clGetExtensionFunctionAddress","clGetPlatformIDs", "clGetGLContextInfoKHR", "clUnloadCompiler", "clCreateContext", "clCreateContextFromType", "clWaitForEvents"] $header_files = ["/usr/include/CL/cl.h", "/usr/include/CL/cl_gl.h", "/usr/include/CL/cl_egl.h", "/usr/include/CL/cl_ext.h"] $windows_header_files = ["/usr/include/CL/cl_dx9_media_sharing.h", "/usr/include/CL/cl_d3d11.h", "/usr/include/CL/cl_d3d10.h"] $cl_data_type_error = { "cl_platform_id" => "CL_INVALID_PLATFORM", "cl_device_id" => "CL_INVALID_DEVICE", "cl_context" => "CL_INVALID_CONTEXT", "cl_command_queue" => "CL_INVALID_COMMAND_QUEUE", "cl_mem" => "CL_INVALID_MEM_OBJECT", "cl_program" => "CL_INVALID_PROGRAM", "cl_kernel" => "CL_INVALID_KERNEL", "cl_event" => "CL_INVALID_EVENT", "cl_sampler" => "CL_INVALID_SAMPLER"} $non_standard_error = [ "clGetExtensionFunctionAddressForPlatform", "clSVMAlloc" ] $versions_entries = [] $buff=50 $license = < Copyright (c) 2012-2020, Vincent Danjean All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. Do not edit this file. It is automatically generated. EOF ########################################################## ########################################################## # helper functions def self.parse_headers api_entries = [] $header_files.each{ |fname| f = File::open(fname) doc = f.read api_entries += doc.scan(/CL_API_ENTRY.*?;/m) f.close } api_entries.each{ |entry| # puts entry begin entry_name = entry.match(/CL_API_CALL(.*?)\(/m)[1].strip rescue entry_name = entry.match(/(\S*?)\(/m)[1].strip end next if entry_name.match('\*') next if entry_name.match("INTEL") next if entry_name.match("APPLE") $api_entries[entry_name] = entry.gsub("\r","") } # $api_entries.each{ |key, value| # puts "#{key}: #{value}" # } end def self.load_database(yamlfile, with_windows=false) doc = YAML::load_file(yamlfile) $known_entries = {} $api_entries ||= {} $versions_entries = Hash::new { |hash,key| hash[key]=[] } entry_name = "" version = "" doc.each { |key, value| #puts (key.to_s+":: "+value) begin entry_name = value.match(/CL_API_CALL(.*?)\(/m)[1].strip rescue entry_name = value.match(/(\S*?)\(/m)[1].strip end next if (!with_windows) && $windows_funcs.include?(entry_name) version = value.match(/SUFFIX__VERSION_(\d_\d)/m)[1] $versions_entries[version].push(entry_name) $known_entries[key] = entry_name $key_entries[entry_name] = key $api_entries[entry_name] = value } $api_entries_array = [] ($known_entries.length+$buff).times { |i| #puts (i.to_s+": "+$known_entries[i]) if $known_entries[i] then $api_entries_array.push( $api_entries[$known_entries[i]] ) else $api_entries_array.push( "CL_API_ENTRY cl_int CL_API_CALL clUnknown#{i}(void);" ) end } end def self.include_headers headers ="" $header_files.each { |h| if h.match('^/usr/include/') then headers += "#include <#{h[13..-1]}>\n" else headers += "#include \"#{h}\"\n" end } return headers end def self.include_headers_no_warnings headers_no_warn = "" headers_no_warn << "#pragma GCC diagnostic push\n" headers_no_warn << "# pragma GCC diagnostic ignored \"-Wcpp\"\n" headers_no_warn << "# define CL_USE_DEPRECATED_OPENCL_1_0_APIS\n" headers_no_warn << "# define CL_USE_DEPRECATED_OPENCL_1_1_APIS\n" headers_no_warn << "# define CL_USE_DEPRECATED_OPENCL_1_2_APIS\n" headers_no_warn << "# define CL_USE_DEPRECATED_OPENCL_2_0_APIS\n" headers_no_warn << "# define CL_USE_DEPRECATED_OPENCL_2_1_APIS\n" headers_no_warn << "# define CL_USE_DEPRECATED_OPENCL_2_2_APIS\n" headers_no_warn << "# define CL_TARGET_OPENCL_VERSION 300\n" headers_no_warn << "# include \n" headers_no_warn << self.include_headers headers_no_warn << "#pragma GCC diagnostic pop\n" headers_no_warn end ########################################################## ########################################################## # generate mode def self.generate_libdummy_icd_header libdummy_icd_structures = "/**\n#{$license}\n*/\n" libdummy_icd_structures += "#define CL_TARGET_OPENCL_VERSION 300\n" libdummy_icd_structures += "#include \n" libdummy_icd_structures += self.include_headers libdummy_icd_structures += "\n\nstruct _cl_icd_dispatch;\n" libdummy_icd_structures += "struct _cl_platform_id { struct _cl_icd_dispatch *dispatch; };\n\n" libdummy_icd_structures += "struct _cl_icd_dispatch {\n" ($api_entries.length+$buff).times { |i| if( $known_entries[i] ) then libdummy_icd_structures += " void(*known#{i})(void);\n" else libdummy_icd_structures += " void(*unknown#{i})(void);\n" end } libdummy_icd_structures += "};\n\n" libdummy_icd_structures += "#pragma GCC visibility push(hidden)\n\n" libdummy_icd_structures += "extern struct _cl_icd_dispatch master_dispatch; \n\n" libdummy_icd_structures += "#if defined(__APPLE__) || defined(__MACOSX)\n" $use_name_in_test.each { |k, f| libdummy_icd_structures += "#define INT#{f} #{f}\n" } libdummy_icd_structures += "#else\n" $use_name_in_test.each { |k, f| libdummy_icd_structures += "typeof(#{f}) INT#{f};\n" } libdummy_icd_structures += "#endif\n" libdummy_icd_structures += "#pragma GCC visibility pop\n\n" return libdummy_icd_structures end def self.generate_libdummy_icd_source libdummy_icd_source = "/**\n#{$license}\n*/\n\n" libdummy_icd_source += "#include \n\n" libdummy_icd_source += "#include \"libdummy_icd_gen.h\"\n\n" libdummy_icd_source += "#include \"libdummy_icd.h\"\n\n" (0...$api_entries.length+$buff).each { |i| libdummy_icd_source += "void dummyFunc#{i}(void){ printf(\"#{i} : \"); fflush(NULL); }\n" } libdummy_icd_source += "\nstruct _cl_icd_dispatch master_dispatch = {\n" comma="," ($api_entries.length+$buff).times { |i| comma="" if (i == $api_entries.length+$buff-1) if( $use_name_in_test[i] ) then libdummy_icd_source += " (void(*)(void))& INT#{$known_entries[i]}#{comma}\n" else libdummy_icd_source += " (void(*)(void))& dummyFunc#{i}#{comma}\n" end } libdummy_icd_source += "};\n" return libdummy_icd_source end def self.generate_run_dummy_icd_source run_dummy_icd = "/**\n#{$license}\n*/\n" run_dummy_icd += "#include \n" run_dummy_icd += "#include \n" run_dummy_icd += self.include_headers_no_warnings run_dummy_icd += "\n\n" $api_entries.each_key { |func_name| next if $forbidden_funcs.include?(func_name) run_dummy_icd += $api_entries[func_name]+"\n" } run_dummy_icd += "\n\n" run_dummy_icd += "void call_all_OpenCL_functions(cl_platform_id chosen_platform) {\n" run_dummy_icd += " cl_context_properties properties[] = { CL_CONTEXT_PLATFORM, (cl_context_properties)chosen_platform, 0 };\n" $api_entries.each_key { |func_name| next if $forbidden_funcs.include?(func_name) if func_name == "clCreateContext" then run_dummy_icd += " #{func_name}(properties,1,(cl_device_id*)&chosen_platform,NULL,NULL,NULL);\n" elsif func_name == "clGetGLContextInfoKHR" then run_dummy_icd += " #{func_name}(properties,CL_CURRENT_DEVICE_FOR_GL_CONTEXT_KHR, 0, NULL, NULL);\n" elsif func_name == "clCreateContextFromType" then run_dummy_icd += " #{func_name}(properties,CL_DEVICE_TYPE_CPU,NULL,NULL,NULL);\n" elsif func_name == "clWaitForEvents" then run_dummy_icd += " #{func_name}(1,(cl_event*)&chosen_platform);\n" elsif func_name == "clGetExtensionFunctionAddress" then run_dummy_icd += " #{func_name}(\"extLIG\");\n" elsif func_name == "clGetExtensionFunctionAddressForPlatform" then run_dummy_icd += " #{func_name}((cl_platform_id )chosen_platform,\"extLIG\");\n" elsif func_name == "clUnloadCompiler" then run_dummy_icd += " #{func_name}();\n" else params = $api_entries[func_name].gsub(/[[:space:]]+/, ' ') params.gsub!(/[\/][*](([^*]*)[*][^\/])*[^*]*[*][\/]/,'') params.gsub!(/^[^(]*[(] *(.*[^ ]) *[)][^)]*$/, '\1') params = params.gsub(/[^,(]+([(][^)]*[)])*[^,]*/) { |p| p.gsub!("[]", "*") p.gsub!("user_func", "") if false && p.match(/[*]/) then "NULL" else "(#{p})0" end } if func_name != "clGetPlatformIDs" then params.gsub!(/^([^0]*)0/, '\1chosen_platform') end run_dummy_icd += " #{func_name}(#{params});\n" end run_dummy_icd += " printf(\"%s\\n\", \"#{func_name}\");\n" run_dummy_icd += "#ifdef OCL_ICD_PRINT_EXPECTED\n" run_dummy_icd += " printf(\"#{$key_entries[func_name]} : %s (expected)\\n\", \"#{func_name}\");\n" run_dummy_icd += "#endif\n" run_dummy_icd += " fflush(NULL);\n" } run_dummy_icd += " return;\n}\n" return run_dummy_icd end def self.generate_run_dummy_icd_weak_source run_dummy_icd_weak = "/**\n#{$license}\n*/\n" run_dummy_icd_weak += < #include EOF run_dummy_icd_weak += self.include_headers_no_warnings $api_entries.each { |func_name, entry| next if $noweak_funcs.include?(func_name) clean_entry = entry.sub(/(.*\)).*/m,'\1').gsub("/*","").gsub("*/","").gsub("\r","") + "{\n" return_type = entry.match(/CL_API_ENTRY (.*) CL_API_CALL/)[1] parameters = clean_entry.match(/\(.*\)/m)[0][1..-2] parameters.gsub!(/\[.*?\]/,"") parameters.sub!(/\(.*?\*\s*(.*?)\)\s*\(.*?\)/m,'\1') run_dummy_icd_weak += clean_entry.gsub(/\*\[.*?\]/,"* ").gsub(/\[.+?\]/,"") first_parameter = parameters.match(/.*?\,/m) if not first_parameter then first_parameter = parameters.match(/.*/m)[0] else first_parameter = first_parameter[0][0..-2] end fps = first_parameter.split run_dummy_icd_weak += " void (*p)()=dlsym(RTLD_NEXT, \"#{func_name}\");\n" ps = parameters.split(",") ps = ps.collect { |p| p = p.split p = p[-1].gsub("*","") } run_dummy_icd_weak += " if(p) {\n" run_dummy_icd_weak += " return((*(typeof(#{func_name})*)p)(" run_dummy_icd_weak += ps.join(", ") run_dummy_icd_weak += "));\n" run_dummy_icd_weak += " } else {\n" run_dummy_icd_weak += " printf(\"-1 : \");\n" run_dummy_icd_weak += " return (#{return_type})0;\n" run_dummy_icd_weak += " }\n" run_dummy_icd_weak += "}\n\n" } return run_dummy_icd_weak end def self.generate_icd_layer_source icd_layer_source = "/**\n#{$license}\n*/\n" icd_layer_source += < #include #define CL_USE_DEPRECATED_OPENCL_1_0_APIS #define CL_USE_DEPRECATED_OPENCL_1_1_APIS #define CL_USE_DEPRECATED_OPENCL_1_2_APIS #define CL_USE_DEPRECATED_OPENCL_2_0_APIS #define CL_USE_DEPRECATED_OPENCL_2_1_APIS #define CL_USE_DEPRECATED_OPENCL_2_2_APIS #define CL_TARGET_OPENCL_VERSION 300 #ifdef HAVE_OPENCL_CL_LAYER_H #include #elif defined HAVE_CL_CL_LAYER_H #include #else #include "khronos-headers/CL/cl_layer.h" #endif static struct _cl_icd_dispatch dispatch = {NULL}; static const struct _cl_icd_dispatch *tdispatch; static const cl_layer_api_version layer_api_version = CL_LAYER_API_VERSION_100; static const char layer_name[] = "dummylayer"; CL_API_ENTRY cl_int CL_API_CALL clGetLayerInfo( cl_layer_info param_name, size_t param_value_size, void *param_value, size_t *param_value_size_ret) { size_t sz = 0; const void *src = NULL; if (param_value_size && !param_value) return CL_INVALID_VALUE; if (!param_value && !param_value_size_ret) return CL_INVALID_VALUE; switch (param_name) { case CL_LAYER_API_VERSION: sz = sizeof(cl_layer_api_version); src = &layer_api_version; break; case CL_LAYER_NAME: sz = sizeof(layer_name); src = layer_name; break; default: return CL_INVALID_VALUE; } if (param_value && param_value_size < sz) return CL_INVALID_VALUE; if (param_value) memcpy(param_value, src, sz); if (param_value_size_ret) *param_value_size_ret = sz; return CL_SUCCESS; } static void _init_dispatch(void); CL_API_ENTRY cl_int CL_API_CALL clInitLayer( cl_uint num_entries, const struct _cl_icd_dispatch *target_dispatch, cl_uint *num_entries_out, const struct _cl_icd_dispatch **layer_dispatch) { if (!target_dispatch || !layer_dispatch ||!num_entries_out || num_entries < sizeof(dispatch)/sizeof(dispatch.clGetPlatformIDs)) return -1; _init_dispatch(); tdispatch = target_dispatch; *layer_dispatch = &dispatch; *num_entries_out = sizeof(dispatch)/sizeof(dispatch.clGetPlatformIDs); return CL_SUCCESS; } EOF $api_entries.each { |func_name, entry| clean_entry = entry.sub(/(.*\)).*/m,'\1').gsub("/*","").gsub("*/","").gsub("\r","") + "{\n" return_type = entry.match(/CL_API_ENTRY (.*) CL_API_CALL/)[1] parameters = clean_entry.match(/\(.*\)/m)[0][1..-2] parameters.gsub!(/\[.*?\]/,"") parameters.sub!(/\(.*?\*\s*(.*?)\)\s*\(.*?\)/m,'\1') clean_entry = clean_entry.gsub(func_name, func_name+"_wrap").gsub("CL_API_ENTRY", "").gsub("CL_API_CALL", "") icd_layer_source += "static " icd_layer_source += clean_entry.gsub(/\*\[.*?\]/,"* ").gsub(/\[.+?\]/,"") ps = parameters.split(",") ps = ps.collect { |p| p = p.split p = p[-1].gsub("*","") } icd_layer_source += " printf(\"#{func_name}\\n\");\n" icd_layer_source += " return tdispatch->#{func_name}(" if func_name != "clUnloadCompiler" icd_layer_source += ps.join(", ") end icd_layer_source += ");\n" icd_layer_source += "}\n\n" } icd_layer_source += "static void _init_dispatch(void) {\n" $api_entries.each { |func_name, _| icd_layer_source += " dispatch.#{func_name} = &#{func_name}_wrap;\n" } icd_layer_source += "}" icd_layer_source end def self.generate_sources(from_headers=true, from_database=false, database=nil) if from_headers then parse_headers end if from_database then load_database(database) end File.open('libdummy_icd_gen.h','w') { |f| f.puts generate_libdummy_icd_header } File.open('libdummy_icd_gen.c','w') { |f| f.puts generate_libdummy_icd_source } File.open('run_dummy_icd_gen.c','w') { |f| f.puts generate_run_dummy_icd_source } File.open('run_dummy_icd_weak_gen.c','w') { |f| f.puts generate_run_dummy_icd_weak_source } File.open('dummy_icd_layer_gen.c','w') { |f| f.puts generate_icd_layer_source } end ########################################################## ########################################################## # database mode def self.generate_ocl_icd_header ocl_icd_header = "/**\n#{$license}\n*/\n\n" ocl_icd_header += "#ifndef OCL_ICD_H\n" ocl_icd_header += "#define OCL_ICD_H\n" ocl_icd_header += self.include_headers_no_warnings ocl_icd_header += < param_value_size ) return CL_INVALID_VALUE; memcpy(param_value, string_p, size_string); } if( param_value_size_ret != NULL ) *param_value_size_ret = size_string; return CL_SUCCESS; } EOF return ocl_icd_bindings_source end def self.generate_get_extension_address_for_platform src = < 3 && (strcmp(func_name+lenfn-3, "KHR")==0 || strcmp(func_name+lenfn-3, "EXT")==0)) { while (fn->name != NULL) { if (strcmp(func_name, fn->name)==0) RETURN(fn->addr); fn++; } } EOF return src end def self.generate_ocl_icd_loader_gen_source skip_funcs = $specific_loader_funcs ocl_icd_loader_gen_source = < #include "ocl_icd_loader.h" #define DEBUG_OCL_ICD_PROVIDE_DUMP_FIELD #include "ocl_icd_debug.h" #define hidden_alias(name) \\ typeof(name) name##_hid __attribute__ ((alias (#name), visibility("hidden"))) EOF cleanup = proc { |entry| clean_entry = entry.sub(/(.*\)).*/m,'\1').gsub("/*","").gsub("*/","").gsub("\r","") + "{\n" return_type = entry.match(/CL_API_ENTRY (.*) CL_API_CALL/)[1] parameters = clean_entry.match(/\(.*\)/m)[0][1..-2] parameters.gsub!(/\[.*?\]/,"") parameters.sub!(/\(.*?\*\s*(.*?)\)\s*\(.*?\)/m,'\1') ps = parameters.split(",") ps = ps.collect { |p| p = p.split p = p[-1].gsub("*","") } [clean_entry, return_type, parameters, ps] } api_stub = proc { |(func_name, entry)| clean_entry, return_type, parameters, ps = cleanup.call(entry) clean_entry = clean_entry.gsub(func_name, func_name+"_unsupp").gsub("CL_API_ENTRY", "") ocl_icd_loader_gen_source += 'static ' ocl_icd_loader_gen_source += clean_entry.gsub(/\*\[.*?\]/,"* ").gsub(/\[.+?\]/,"") if(ps.include?("errcode_ret")) then ocl_icd_loader_gen_source += " if( errcode_ret != NULL ) {\n"; ocl_icd_loader_gen_source += " *errcode_ret = CL_INVALID_OPERATION;\n" ocl_icd_loader_gen_source += " }\n" if return_type != "void" then ocl_icd_loader_gen_source += " RETURN(NULL);\n" else ocl_icd_loader_gen_source += " return;\n" end elsif ($non_standard_error.include?(func_name)) then if return_type != "void" then ocl_icd_loader_gen_source += " RETURN(NULL);\n" else ocl_icd_loader_gen_source += " return;\n" end elsif func_name == "clGetExtensionFunctionAddress" ocl_icd_loader_gen_source += " return NULL;\n" else if return_type != "void" then ocl_icd_loader_gen_source += " RETURN(CL_INVALID_OPERATION);\n" if return_type != "void" else ocl_icd_loader_gen_source += " return;\n" end end ocl_icd_loader_gen_source += "}\n\n" } api_proc = proc { |disp, (func_name, entry)| next if skip_funcs.include?(func_name) clean_entry, return_type, parameters, ps = cleanup.call(entry) if disp clean_entry = clean_entry.gsub(func_name, func_name+"_disp").gsub("CL_API_ENTRY", "").gsub("CL_API_CALL", "") ocl_icd_loader_gen_source += '__attribute__((visibility("hidden"))) ' end ocl_icd_loader_gen_source += clean_entry.gsub(/\*\[.*?\]/,"* ").gsub(/\[.+?\]/,"") first_parameter = parameters.match(/.*?\,/m) if not first_parameter then first_parameter = parameters.match(/.*/m)[0] else first_parameter = first_parameter[0][0..-2] end fps = first_parameter.split if !disp ocl_icd_loader_gen_source += " debug_trace();\n" ocl_icd_loader_gen_source += " _initClIcd_no_inline();\n" if fps[0] == "cl_platform_id" ocl_icd_loader_gen_source += " if (_first_layer)\n" ocl_icd_loader_gen_source += " return _first_layer->dispatch.#{func_name}(" ocl_icd_loader_gen_source += ps.join(", ") ocl_icd_loader_gen_source += ");\n" end ocl_icd_loader_gen_source += generate_get_extension_address_for_platform if func_name == "clGetExtensionFunctionAddressForPlatform" raise "Unsupported data_type #{fps[0]}" if ! $cl_data_type_error[fps[0]] error_handler = lambda { if(ps.include?("errcode_ret")) then ocl_icd_loader_gen_source += " if( errcode_ret != NULL ) {\n"; ocl_icd_loader_gen_source += " *errcode_ret = #{$cl_data_type_error[fps[0]]};\n" ocl_icd_loader_gen_source += " }\n" if return_type != "void" then ocl_icd_loader_gen_source += " RETURN(NULL);\n" else ocl_icd_loader_gen_source += " return;\n" end elsif ($non_standard_error.include?(func_name)) then if return_type != "void" then ocl_icd_loader_gen_source += " RETURN(NULL);\n" else ocl_icd_loader_gen_source += " return;\n" end else if return_type != "void" then ocl_icd_loader_gen_source += " RETURN(#{$cl_data_type_error[fps[0]]});\n" if return_type != "void" else ocl_icd_loader_gen_source += " return;\n" end end } if(fps[0] == "cl_platform_id") then ocl_icd_loader_gen_source += " #{fps[1]}=selectPlatformID(#{fps[1]});\n" end ocl_icd_loader_gen_source += " if( (struct _#{fps[0]} *)#{fps[1]} == NULL) {\n" error_handler.call ocl_icd_loader_gen_source += " }\n" if return_type != "void" then return_debug="RETURN" else return_debug="return" end ocl_icd_loader_gen_source += " #{return_debug}(KHR_ICD2_DISPATCH((struct _#{fps[0]} *)#{fps[1]})->#{func_name}(" ocl_icd_loader_gen_source += ps.join(", ") ocl_icd_loader_gen_source += "));\n" ocl_icd_loader_gen_source += "}\n\n" } $api_entries.each &(api_stub) $api_entries.each &(api_proc.curry[true]) $api_entries.each &(api_proc.curry[false]) ocl_icd_loader_gen_source += "#pragma GCC visibility push(hidden)\n\n" skip_funcs = $specific_loader_funcs $api_entries.each { |func_name, entry| #next if func_name.match(/EXT$/) #next if func_name.match(/KHR$/) if (skip_funcs.include?(func_name)) then ocl_icd_loader_gen_source += <#{e} = (typeof(#{e})*)pltfn_fn_ptr(pid, "#{e}"); if (!dispatch->#{e}) dispatch->#{e} = #{e}_unsupp; EOF else ocl_icd_loader_gen_source << " dispatch->clUnknown#{i} = NULL;\n" end } ocl_icd_loader_gen_source << < #include #ifdef __cplusplus extern "C" { #endif /******************************************************************************/ typedef struct _cl_platform_id * cl_platform_id; typedef struct _cl_device_id * cl_device_id; typedef struct _cl_context * cl_context; typedef struct _cl_command_queue * cl_command_queue; typedef struct _cl_mem * cl_mem; typedef struct _cl_program * cl_program; typedef struct _cl_kernel * cl_kernel; typedef struct _cl_event * cl_event; typedef struct _cl_sampler * cl_sampler; typedef cl_uint cl_bool; /* WARNING! Unlike cl_ types in cl_platform.h, cl_bool is not guaranteed to be the same size as the bool in kernels. */ typedef cl_ulong cl_bitfield; typedef cl_ulong cl_properties; typedef cl_bitfield cl_device_type; typedef cl_uint cl_platform_info; typedef cl_uint cl_device_info; typedef cl_bitfield cl_device_fp_config; typedef cl_uint cl_device_mem_cache_type; typedef cl_uint cl_device_local_mem_type; typedef cl_bitfield cl_device_exec_capabilities; #ifdef CL_VERSION_2_0 typedef cl_bitfield cl_device_svm_capabilities; #endif typedef cl_bitfield cl_command_queue_properties; #ifdef CL_VERSION_1_2 typedef intptr_t cl_device_partition_property; typedef cl_bitfield cl_device_affinity_domain; #endif typedef intptr_t cl_context_properties; typedef cl_uint cl_context_info; #ifdef CL_VERSION_2_0 typedef cl_properties cl_queue_properties; #endif typedef cl_uint cl_command_queue_info; typedef cl_uint cl_channel_order; typedef cl_uint cl_channel_type; typedef cl_bitfield cl_mem_flags; #ifdef CL_VERSION_2_0 typedef cl_bitfield cl_svm_mem_flags; #endif typedef cl_uint cl_mem_object_type; typedef cl_uint cl_mem_info; #ifdef CL_VERSION_1_2 typedef cl_bitfield cl_mem_migration_flags; #endif typedef cl_uint cl_image_info; #ifdef CL_VERSION_1_1 typedef cl_uint cl_buffer_create_type; #endif typedef cl_uint cl_addressing_mode; typedef cl_uint cl_filter_mode; typedef cl_uint cl_sampler_info; typedef cl_bitfield cl_map_flags; #ifdef CL_VERSION_2_0 typedef intptr_t cl_pipe_properties; typedef cl_uint cl_pipe_info; #endif typedef cl_uint cl_program_info; typedef cl_uint cl_program_build_info; #ifdef CL_VERSION_1_2 typedef cl_uint cl_program_binary_type; #endif typedef cl_int cl_build_status; typedef cl_uint cl_kernel_info; #ifdef CL_VERSION_1_2 typedef cl_uint cl_kernel_arg_info; typedef cl_uint cl_kernel_arg_address_qualifier; typedef cl_uint cl_kernel_arg_access_qualifier; typedef cl_bitfield cl_kernel_arg_type_qualifier; #endif typedef cl_uint cl_kernel_work_group_info; #ifdef CL_VERSION_2_1 typedef cl_uint cl_kernel_sub_group_info; #endif typedef cl_uint cl_event_info; typedef cl_uint cl_command_type; typedef cl_uint cl_profiling_info; #ifdef CL_VERSION_2_0 typedef cl_properties cl_sampler_properties; typedef cl_uint cl_kernel_exec_info; #endif #ifdef CL_VERSION_3_0 typedef cl_bitfield cl_device_atomic_capabilities; typedef cl_bitfield cl_device_device_enqueue_capabilities; typedef cl_uint cl_khronos_vendor_id; typedef cl_properties cl_mem_properties; typedef cl_uint cl_version; #endif typedef struct _cl_image_format { cl_channel_order image_channel_order; cl_channel_type image_channel_data_type; } cl_image_format; #ifdef CL_VERSION_1_2 typedef struct _cl_image_desc { cl_mem_object_type image_type; size_t image_width; size_t image_height; size_t image_depth; size_t image_array_size; size_t image_row_pitch; size_t image_slice_pitch; cl_uint num_mip_levels; cl_uint num_samples; #ifdef CL_VERSION_2_0 #if defined(__GNUC__) __extension__ /* Prevents warnings about anonymous union in -pedantic builds */ #endif #if defined(_MSC_VER) && !defined(__STDC__) #pragma warning( push ) #pragma warning( disable : 4201 ) /* Prevents warning about nameless struct/union in /W4 builds */ #endif #ifdef __clang__ #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc11-extensions" /* Prevents warning about nameless union being C11 extension*/ #endif #if defined(_MSC_VER) && defined(__STDC__) /* Anonymous unions are not supported in /Za builds */ #else union { #endif #endif cl_mem buffer; #ifdef CL_VERSION_2_0 #if defined(_MSC_VER) && defined(__STDC__) /* Anonymous unions are not supported in /Za builds */ #else cl_mem mem_object; }; #endif #if defined(_MSC_VER) && !defined(__STDC__) #pragma warning( pop ) #endif #ifdef __clang__ #pragma clang diagnostic pop #endif #endif } cl_image_desc; #endif #ifdef CL_VERSION_1_1 typedef struct _cl_buffer_region { size_t origin; size_t size; } cl_buffer_region; #endif #ifdef CL_VERSION_3_0 #define CL_NAME_VERSION_MAX_NAME_SIZE 64 typedef struct _cl_name_version { cl_version version; char name[CL_NAME_VERSION_MAX_NAME_SIZE]; } cl_name_version; #endif /******************************************************************************/ /* Error Codes */ #define CL_SUCCESS 0 #define CL_DEVICE_NOT_FOUND -1 #define CL_DEVICE_NOT_AVAILABLE -2 #define CL_COMPILER_NOT_AVAILABLE -3 #define CL_MEM_OBJECT_ALLOCATION_FAILURE -4 #define CL_OUT_OF_RESOURCES -5 #define CL_OUT_OF_HOST_MEMORY -6 #define CL_PROFILING_INFO_NOT_AVAILABLE -7 #define CL_MEM_COPY_OVERLAP -8 #define CL_IMAGE_FORMAT_MISMATCH -9 #define CL_IMAGE_FORMAT_NOT_SUPPORTED -10 #define CL_BUILD_PROGRAM_FAILURE -11 #define CL_MAP_FAILURE -12 #ifdef CL_VERSION_1_1 #define CL_MISALIGNED_SUB_BUFFER_OFFSET -13 #define CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST -14 #endif #ifdef CL_VERSION_1_2 #define CL_COMPILE_PROGRAM_FAILURE -15 #define CL_LINKER_NOT_AVAILABLE -16 #define CL_LINK_PROGRAM_FAILURE -17 #define CL_DEVICE_PARTITION_FAILED -18 #define CL_KERNEL_ARG_INFO_NOT_AVAILABLE -19 #endif #define CL_INVALID_VALUE -30 #define CL_INVALID_DEVICE_TYPE -31 #define CL_INVALID_PLATFORM -32 #define CL_INVALID_DEVICE -33 #define CL_INVALID_CONTEXT -34 #define CL_INVALID_QUEUE_PROPERTIES -35 #define CL_INVALID_COMMAND_QUEUE -36 #define CL_INVALID_HOST_PTR -37 #define CL_INVALID_MEM_OBJECT -38 #define CL_INVALID_IMAGE_FORMAT_DESCRIPTOR -39 #define CL_INVALID_IMAGE_SIZE -40 #define CL_INVALID_SAMPLER -41 #define CL_INVALID_BINARY -42 #define CL_INVALID_BUILD_OPTIONS -43 #define CL_INVALID_PROGRAM -44 #define CL_INVALID_PROGRAM_EXECUTABLE -45 #define CL_INVALID_KERNEL_NAME -46 #define CL_INVALID_KERNEL_DEFINITION -47 #define CL_INVALID_KERNEL -48 #define CL_INVALID_ARG_INDEX -49 #define CL_INVALID_ARG_VALUE -50 #define CL_INVALID_ARG_SIZE -51 #define CL_INVALID_KERNEL_ARGS -52 #define CL_INVALID_WORK_DIMENSION -53 #define CL_INVALID_WORK_GROUP_SIZE -54 #define CL_INVALID_WORK_ITEM_SIZE -55 #define CL_INVALID_GLOBAL_OFFSET -56 #define CL_INVALID_EVENT_WAIT_LIST -57 #define CL_INVALID_EVENT -58 #define CL_INVALID_OPERATION -59 #define CL_INVALID_GL_OBJECT -60 #define CL_INVALID_BUFFER_SIZE -61 #define CL_INVALID_MIP_LEVEL -62 #define CL_INVALID_GLOBAL_WORK_SIZE -63 #ifdef CL_VERSION_1_1 #define CL_INVALID_PROPERTY -64 #endif #ifdef CL_VERSION_1_2 #define CL_INVALID_IMAGE_DESCRIPTOR -65 #define CL_INVALID_COMPILER_OPTIONS -66 #define CL_INVALID_LINKER_OPTIONS -67 #define CL_INVALID_DEVICE_PARTITION_COUNT -68 #endif #ifdef CL_VERSION_2_0 #define CL_INVALID_PIPE_SIZE -69 #define CL_INVALID_DEVICE_QUEUE -70 #endif #ifdef CL_VERSION_2_2 #define CL_INVALID_SPEC_ID -71 #define CL_MAX_SIZE_RESTRICTION_EXCEEDED -72 #endif /* cl_bool */ #define CL_FALSE 0 #define CL_TRUE 1 #ifdef CL_VERSION_1_2 #define CL_BLOCKING CL_TRUE #define CL_NON_BLOCKING CL_FALSE #endif /* cl_platform_info */ #define CL_PLATFORM_PROFILE 0x0900 #define CL_PLATFORM_VERSION 0x0901 #define CL_PLATFORM_NAME 0x0902 #define CL_PLATFORM_VENDOR 0x0903 #define CL_PLATFORM_EXTENSIONS 0x0904 #ifdef CL_VERSION_2_1 #define CL_PLATFORM_HOST_TIMER_RESOLUTION 0x0905 #endif #ifdef CL_VERSION_3_0 #define CL_PLATFORM_NUMERIC_VERSION 0x0906 #define CL_PLATFORM_EXTENSIONS_WITH_VERSION 0x0907 #endif /* cl_device_type - bitfield */ #define CL_DEVICE_TYPE_DEFAULT (1 << 0) #define CL_DEVICE_TYPE_CPU (1 << 1) #define CL_DEVICE_TYPE_GPU (1 << 2) #define CL_DEVICE_TYPE_ACCELERATOR (1 << 3) #ifdef CL_VERSION_1_2 #define CL_DEVICE_TYPE_CUSTOM (1 << 4) #endif #define CL_DEVICE_TYPE_ALL 0xFFFFFFFF /* cl_device_info */ #define CL_DEVICE_TYPE 0x1000 #define CL_DEVICE_VENDOR_ID 0x1001 #define CL_DEVICE_MAX_COMPUTE_UNITS 0x1002 #define CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS 0x1003 #define CL_DEVICE_MAX_WORK_GROUP_SIZE 0x1004 #define CL_DEVICE_MAX_WORK_ITEM_SIZES 0x1005 #define CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR 0x1006 #define CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT 0x1007 #define CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT 0x1008 #define CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG 0x1009 #define CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT 0x100A #define CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE 0x100B #define CL_DEVICE_MAX_CLOCK_FREQUENCY 0x100C #define CL_DEVICE_ADDRESS_BITS 0x100D #define CL_DEVICE_MAX_READ_IMAGE_ARGS 0x100E #define CL_DEVICE_MAX_WRITE_IMAGE_ARGS 0x100F #define CL_DEVICE_MAX_MEM_ALLOC_SIZE 0x1010 #define CL_DEVICE_IMAGE2D_MAX_WIDTH 0x1011 #define CL_DEVICE_IMAGE2D_MAX_HEIGHT 0x1012 #define CL_DEVICE_IMAGE3D_MAX_WIDTH 0x1013 #define CL_DEVICE_IMAGE3D_MAX_HEIGHT 0x1014 #define CL_DEVICE_IMAGE3D_MAX_DEPTH 0x1015 #define CL_DEVICE_IMAGE_SUPPORT 0x1016 #define CL_DEVICE_MAX_PARAMETER_SIZE 0x1017 #define CL_DEVICE_MAX_SAMPLERS 0x1018 #define CL_DEVICE_MEM_BASE_ADDR_ALIGN 0x1019 #define CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE 0x101A #define CL_DEVICE_SINGLE_FP_CONFIG 0x101B #define CL_DEVICE_GLOBAL_MEM_CACHE_TYPE 0x101C #define CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE 0x101D #define CL_DEVICE_GLOBAL_MEM_CACHE_SIZE 0x101E #define CL_DEVICE_GLOBAL_MEM_SIZE 0x101F #define CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE 0x1020 #define CL_DEVICE_MAX_CONSTANT_ARGS 0x1021 #define CL_DEVICE_LOCAL_MEM_TYPE 0x1022 #define CL_DEVICE_LOCAL_MEM_SIZE 0x1023 #define CL_DEVICE_ERROR_CORRECTION_SUPPORT 0x1024 #define CL_DEVICE_PROFILING_TIMER_RESOLUTION 0x1025 #define CL_DEVICE_ENDIAN_LITTLE 0x1026 #define CL_DEVICE_AVAILABLE 0x1027 #define CL_DEVICE_COMPILER_AVAILABLE 0x1028 #define CL_DEVICE_EXECUTION_CAPABILITIES 0x1029 #define CL_DEVICE_QUEUE_PROPERTIES 0x102A /* deprecated */ #ifdef CL_VERSION_2_0 #define CL_DEVICE_QUEUE_ON_HOST_PROPERTIES 0x102A #endif #define CL_DEVICE_NAME 0x102B #define CL_DEVICE_VENDOR 0x102C #define CL_DRIVER_VERSION 0x102D #define CL_DEVICE_PROFILE 0x102E #define CL_DEVICE_VERSION 0x102F #define CL_DEVICE_EXTENSIONS 0x1030 #define CL_DEVICE_PLATFORM 0x1031 #ifdef CL_VERSION_1_2 #define CL_DEVICE_DOUBLE_FP_CONFIG 0x1032 #endif /* 0x1033 reserved for CL_DEVICE_HALF_FP_CONFIG which is already defined in "cl_ext.h" */ #ifdef CL_VERSION_1_1 #define CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF 0x1034 #define CL_DEVICE_HOST_UNIFIED_MEMORY 0x1035 /* deprecated */ #define CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR 0x1036 #define CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT 0x1037 #define CL_DEVICE_NATIVE_VECTOR_WIDTH_INT 0x1038 #define CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG 0x1039 #define CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT 0x103A #define CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE 0x103B #define CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF 0x103C #define CL_DEVICE_OPENCL_C_VERSION 0x103D #endif #ifdef CL_VERSION_1_2 #define CL_DEVICE_LINKER_AVAILABLE 0x103E #define CL_DEVICE_BUILT_IN_KERNELS 0x103F #define CL_DEVICE_IMAGE_MAX_BUFFER_SIZE 0x1040 #define CL_DEVICE_IMAGE_MAX_ARRAY_SIZE 0x1041 #define CL_DEVICE_PARENT_DEVICE 0x1042 #define CL_DEVICE_PARTITION_MAX_SUB_DEVICES 0x1043 #define CL_DEVICE_PARTITION_PROPERTIES 0x1044 #define CL_DEVICE_PARTITION_AFFINITY_DOMAIN 0x1045 #define CL_DEVICE_PARTITION_TYPE 0x1046 #define CL_DEVICE_REFERENCE_COUNT 0x1047 #define CL_DEVICE_PREFERRED_INTEROP_USER_SYNC 0x1048 #define CL_DEVICE_PRINTF_BUFFER_SIZE 0x1049 #endif #ifdef CL_VERSION_2_0 #define CL_DEVICE_IMAGE_PITCH_ALIGNMENT 0x104A #define CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT 0x104B #define CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS 0x104C #define CL_DEVICE_MAX_GLOBAL_VARIABLE_SIZE 0x104D #define CL_DEVICE_QUEUE_ON_DEVICE_PROPERTIES 0x104E #define CL_DEVICE_QUEUE_ON_DEVICE_PREFERRED_SIZE 0x104F #define CL_DEVICE_QUEUE_ON_DEVICE_MAX_SIZE 0x1050 #define CL_DEVICE_MAX_ON_DEVICE_QUEUES 0x1051 #define CL_DEVICE_MAX_ON_DEVICE_EVENTS 0x1052 #define CL_DEVICE_SVM_CAPABILITIES 0x1053 #define CL_DEVICE_GLOBAL_VARIABLE_PREFERRED_TOTAL_SIZE 0x1054 #define CL_DEVICE_MAX_PIPE_ARGS 0x1055 #define CL_DEVICE_PIPE_MAX_ACTIVE_RESERVATIONS 0x1056 #define CL_DEVICE_PIPE_MAX_PACKET_SIZE 0x1057 #define CL_DEVICE_PREFERRED_PLATFORM_ATOMIC_ALIGNMENT 0x1058 #define CL_DEVICE_PREFERRED_GLOBAL_ATOMIC_ALIGNMENT 0x1059 #define CL_DEVICE_PREFERRED_LOCAL_ATOMIC_ALIGNMENT 0x105A #endif #ifdef CL_VERSION_2_1 #define CL_DEVICE_IL_VERSION 0x105B #define CL_DEVICE_MAX_NUM_SUB_GROUPS 0x105C #define CL_DEVICE_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS 0x105D #endif #ifdef CL_VERSION_3_0 #define CL_DEVICE_NUMERIC_VERSION 0x105E #define CL_DEVICE_EXTENSIONS_WITH_VERSION 0x1060 #define CL_DEVICE_ILS_WITH_VERSION 0x1061 #define CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION 0x1062 #define CL_DEVICE_ATOMIC_MEMORY_CAPABILITIES 0x1063 #define CL_DEVICE_ATOMIC_FENCE_CAPABILITIES 0x1064 #define CL_DEVICE_NON_UNIFORM_WORK_GROUP_SUPPORT 0x1065 #define CL_DEVICE_OPENCL_C_ALL_VERSIONS 0x1066 #define CL_DEVICE_PREFERRED_WORK_GROUP_SIZE_MULTIPLE 0x1067 #define CL_DEVICE_WORK_GROUP_COLLECTIVE_FUNCTIONS_SUPPORT 0x1068 #define CL_DEVICE_GENERIC_ADDRESS_SPACE_SUPPORT 0x1069 /* 0x106A to 0x106E - Reserved for upcoming KHR extension */ #define CL_DEVICE_OPENCL_C_FEATURES 0x106F #define CL_DEVICE_DEVICE_ENQUEUE_CAPABILITIES 0x1070 #define CL_DEVICE_PIPE_SUPPORT 0x1071 #define CL_DEVICE_LATEST_CONFORMANCE_VERSION_PASSED 0x1072 #endif /* cl_device_fp_config - bitfield */ #define CL_FP_DENORM (1 << 0) #define CL_FP_INF_NAN (1 << 1) #define CL_FP_ROUND_TO_NEAREST (1 << 2) #define CL_FP_ROUND_TO_ZERO (1 << 3) #define CL_FP_ROUND_TO_INF (1 << 4) #define CL_FP_FMA (1 << 5) #ifdef CL_VERSION_1_1 #define CL_FP_SOFT_FLOAT (1 << 6) #endif #ifdef CL_VERSION_1_2 #define CL_FP_CORRECTLY_ROUNDED_DIVIDE_SQRT (1 << 7) #endif /* cl_device_mem_cache_type */ #define CL_NONE 0x0 #define CL_READ_ONLY_CACHE 0x1 #define CL_READ_WRITE_CACHE 0x2 /* cl_device_local_mem_type */ #define CL_LOCAL 0x1 #define CL_GLOBAL 0x2 /* cl_device_exec_capabilities - bitfield */ #define CL_EXEC_KERNEL (1 << 0) #define CL_EXEC_NATIVE_KERNEL (1 << 1) /* cl_command_queue_properties - bitfield */ #define CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE (1 << 0) #define CL_QUEUE_PROFILING_ENABLE (1 << 1) #ifdef CL_VERSION_2_0 #define CL_QUEUE_ON_DEVICE (1 << 2) #define CL_QUEUE_ON_DEVICE_DEFAULT (1 << 3) #endif /* cl_context_info */ #define CL_CONTEXT_REFERENCE_COUNT 0x1080 #define CL_CONTEXT_DEVICES 0x1081 #define CL_CONTEXT_PROPERTIES 0x1082 #ifdef CL_VERSION_1_1 #define CL_CONTEXT_NUM_DEVICES 0x1083 #endif /* cl_context_properties */ #define CL_CONTEXT_PLATFORM 0x1084 #ifdef CL_VERSION_1_2 #define CL_CONTEXT_INTEROP_USER_SYNC 0x1085 #endif #ifdef CL_VERSION_1_2 /* cl_device_partition_property */ #define CL_DEVICE_PARTITION_EQUALLY 0x1086 #define CL_DEVICE_PARTITION_BY_COUNTS 0x1087 #define CL_DEVICE_PARTITION_BY_COUNTS_LIST_END 0x0 #define CL_DEVICE_PARTITION_BY_AFFINITY_DOMAIN 0x1088 #endif #ifdef CL_VERSION_1_2 /* cl_device_affinity_domain */ #define CL_DEVICE_AFFINITY_DOMAIN_NUMA (1 << 0) #define CL_DEVICE_AFFINITY_DOMAIN_L4_CACHE (1 << 1) #define CL_DEVICE_AFFINITY_DOMAIN_L3_CACHE (1 << 2) #define CL_DEVICE_AFFINITY_DOMAIN_L2_CACHE (1 << 3) #define CL_DEVICE_AFFINITY_DOMAIN_L1_CACHE (1 << 4) #define CL_DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE (1 << 5) #endif #ifdef CL_VERSION_2_0 /* cl_device_svm_capabilities */ #define CL_DEVICE_SVM_COARSE_GRAIN_BUFFER (1 << 0) #define CL_DEVICE_SVM_FINE_GRAIN_BUFFER (1 << 1) #define CL_DEVICE_SVM_FINE_GRAIN_SYSTEM (1 << 2) #define CL_DEVICE_SVM_ATOMICS (1 << 3) #endif /* cl_command_queue_info */ #define CL_QUEUE_CONTEXT 0x1090 #define CL_QUEUE_DEVICE 0x1091 #define CL_QUEUE_REFERENCE_COUNT 0x1092 #define CL_QUEUE_PROPERTIES 0x1093 #ifdef CL_VERSION_2_0 #define CL_QUEUE_SIZE 0x1094 #endif #ifdef CL_VERSION_2_1 #define CL_QUEUE_DEVICE_DEFAULT 0x1095 #endif #ifdef CL_VERSION_3_0 #define CL_QUEUE_PROPERTIES_ARRAY 0x1098 #endif /* cl_mem_flags and cl_svm_mem_flags - bitfield */ #define CL_MEM_READ_WRITE (1 << 0) #define CL_MEM_WRITE_ONLY (1 << 1) #define CL_MEM_READ_ONLY (1 << 2) #define CL_MEM_USE_HOST_PTR (1 << 3) #define CL_MEM_ALLOC_HOST_PTR (1 << 4) #define CL_MEM_COPY_HOST_PTR (1 << 5) /* reserved (1 << 6) */ #ifdef CL_VERSION_1_2 #define CL_MEM_HOST_WRITE_ONLY (1 << 7) #define CL_MEM_HOST_READ_ONLY (1 << 8) #define CL_MEM_HOST_NO_ACCESS (1 << 9) #endif #ifdef CL_VERSION_2_0 #define CL_MEM_SVM_FINE_GRAIN_BUFFER (1 << 10) /* used by cl_svm_mem_flags only */ #define CL_MEM_SVM_ATOMICS (1 << 11) /* used by cl_svm_mem_flags only */ #define CL_MEM_KERNEL_READ_AND_WRITE (1 << 12) #endif #ifdef CL_VERSION_1_2 /* cl_mem_migration_flags - bitfield */ #define CL_MIGRATE_MEM_OBJECT_HOST (1 << 0) #define CL_MIGRATE_MEM_OBJECT_CONTENT_UNDEFINED (1 << 1) #endif /* cl_channel_order */ #define CL_R 0x10B0 #define CL_A 0x10B1 #define CL_RG 0x10B2 #define CL_RA 0x10B3 #define CL_RGB 0x10B4 #define CL_RGBA 0x10B5 #define CL_BGRA 0x10B6 #define CL_ARGB 0x10B7 #define CL_INTENSITY 0x10B8 #define CL_LUMINANCE 0x10B9 #ifdef CL_VERSION_1_1 #define CL_Rx 0x10BA #define CL_RGx 0x10BB #define CL_RGBx 0x10BC #endif #ifdef CL_VERSION_1_2 #define CL_DEPTH 0x10BD #define CL_DEPTH_STENCIL 0x10BE #endif #ifdef CL_VERSION_2_0 #define CL_sRGB 0x10BF #define CL_sRGBx 0x10C0 #define CL_sRGBA 0x10C1 #define CL_sBGRA 0x10C2 #define CL_ABGR 0x10C3 #endif /* cl_channel_type */ #define CL_SNORM_INT8 0x10D0 #define CL_SNORM_INT16 0x10D1 #define CL_UNORM_INT8 0x10D2 #define CL_UNORM_INT16 0x10D3 #define CL_UNORM_SHORT_565 0x10D4 #define CL_UNORM_SHORT_555 0x10D5 #define CL_UNORM_INT_101010 0x10D6 #define CL_SIGNED_INT8 0x10D7 #define CL_SIGNED_INT16 0x10D8 #define CL_SIGNED_INT32 0x10D9 #define CL_UNSIGNED_INT8 0x10DA #define CL_UNSIGNED_INT16 0x10DB #define CL_UNSIGNED_INT32 0x10DC #define CL_HALF_FLOAT 0x10DD #define CL_FLOAT 0x10DE #ifdef CL_VERSION_1_2 #define CL_UNORM_INT24 0x10DF #endif #ifdef CL_VERSION_2_1 #define CL_UNORM_INT_101010_2 0x10E0 #endif /* cl_mem_object_type */ #define CL_MEM_OBJECT_BUFFER 0x10F0 #define CL_MEM_OBJECT_IMAGE2D 0x10F1 #define CL_MEM_OBJECT_IMAGE3D 0x10F2 #ifdef CL_VERSION_1_2 #define CL_MEM_OBJECT_IMAGE2D_ARRAY 0x10F3 #define CL_MEM_OBJECT_IMAGE1D 0x10F4 #define CL_MEM_OBJECT_IMAGE1D_ARRAY 0x10F5 #define CL_MEM_OBJECT_IMAGE1D_BUFFER 0x10F6 #endif #ifdef CL_VERSION_2_0 #define CL_MEM_OBJECT_PIPE 0x10F7 #endif /* cl_mem_info */ #define CL_MEM_TYPE 0x1100 #define CL_MEM_FLAGS 0x1101 #define CL_MEM_SIZE 0x1102 #define CL_MEM_HOST_PTR 0x1103 #define CL_MEM_MAP_COUNT 0x1104 #define CL_MEM_REFERENCE_COUNT 0x1105 #define CL_MEM_CONTEXT 0x1106 #ifdef CL_VERSION_1_1 #define CL_MEM_ASSOCIATED_MEMOBJECT 0x1107 #define CL_MEM_OFFSET 0x1108 #endif #ifdef CL_VERSION_2_0 #define CL_MEM_USES_SVM_POINTER 0x1109 #endif #ifdef CL_VERSION_3_0 #define CL_MEM_PROPERTIES 0x110A #endif /* cl_image_info */ #define CL_IMAGE_FORMAT 0x1110 #define CL_IMAGE_ELEMENT_SIZE 0x1111 #define CL_IMAGE_ROW_PITCH 0x1112 #define CL_IMAGE_SLICE_PITCH 0x1113 #define CL_IMAGE_WIDTH 0x1114 #define CL_IMAGE_HEIGHT 0x1115 #define CL_IMAGE_DEPTH 0x1116 #ifdef CL_VERSION_1_2 #define CL_IMAGE_ARRAY_SIZE 0x1117 #define CL_IMAGE_BUFFER 0x1118 #define CL_IMAGE_NUM_MIP_LEVELS 0x1119 #define CL_IMAGE_NUM_SAMPLES 0x111A #endif /* cl_pipe_info */ #ifdef CL_VERSION_2_0 #define CL_PIPE_PACKET_SIZE 0x1120 #define CL_PIPE_MAX_PACKETS 0x1121 #endif #ifdef CL_VERSION_3_0 #define CL_PIPE_PROPERTIES 0x1122 #endif /* cl_addressing_mode */ #define CL_ADDRESS_NONE 0x1130 #define CL_ADDRESS_CLAMP_TO_EDGE 0x1131 #define CL_ADDRESS_CLAMP 0x1132 #define CL_ADDRESS_REPEAT 0x1133 #ifdef CL_VERSION_1_1 #define CL_ADDRESS_MIRRORED_REPEAT 0x1134 #endif /* cl_filter_mode */ #define CL_FILTER_NEAREST 0x1140 #define CL_FILTER_LINEAR 0x1141 /* cl_sampler_info */ #define CL_SAMPLER_REFERENCE_COUNT 0x1150 #define CL_SAMPLER_CONTEXT 0x1151 #define CL_SAMPLER_NORMALIZED_COORDS 0x1152 #define CL_SAMPLER_ADDRESSING_MODE 0x1153 #define CL_SAMPLER_FILTER_MODE 0x1154 #ifdef CL_VERSION_2_0 /* These enumerants are for the cl_khr_mipmap_image extension. They have since been added to cl_ext.h with an appropriate KHR suffix, but are left here for backwards compatibility. */ #define CL_SAMPLER_MIP_FILTER_MODE 0x1155 #define CL_SAMPLER_LOD_MIN 0x1156 #define CL_SAMPLER_LOD_MAX 0x1157 #endif #ifdef CL_VERSION_3_0 #define CL_SAMPLER_PROPERTIES 0x1158 #endif /* cl_map_flags - bitfield */ #define CL_MAP_READ (1 << 0) #define CL_MAP_WRITE (1 << 1) #ifdef CL_VERSION_1_2 #define CL_MAP_WRITE_INVALIDATE_REGION (1 << 2) #endif /* cl_program_info */ #define CL_PROGRAM_REFERENCE_COUNT 0x1160 #define CL_PROGRAM_CONTEXT 0x1161 #define CL_PROGRAM_NUM_DEVICES 0x1162 #define CL_PROGRAM_DEVICES 0x1163 #define CL_PROGRAM_SOURCE 0x1164 #define CL_PROGRAM_BINARY_SIZES 0x1165 #define CL_PROGRAM_BINARIES 0x1166 #ifdef CL_VERSION_1_2 #define CL_PROGRAM_NUM_KERNELS 0x1167 #define CL_PROGRAM_KERNEL_NAMES 0x1168 #endif #ifdef CL_VERSION_2_1 #define CL_PROGRAM_IL 0x1169 #endif #ifdef CL_VERSION_2_2 #define CL_PROGRAM_SCOPE_GLOBAL_CTORS_PRESENT 0x116A #define CL_PROGRAM_SCOPE_GLOBAL_DTORS_PRESENT 0x116B #endif /* cl_program_build_info */ #define CL_PROGRAM_BUILD_STATUS 0x1181 #define CL_PROGRAM_BUILD_OPTIONS 0x1182 #define CL_PROGRAM_BUILD_LOG 0x1183 #ifdef CL_VERSION_1_2 #define CL_PROGRAM_BINARY_TYPE 0x1184 #endif #ifdef CL_VERSION_2_0 #define CL_PROGRAM_BUILD_GLOBAL_VARIABLE_TOTAL_SIZE 0x1185 #endif #ifdef CL_VERSION_1_2 /* cl_program_binary_type */ #define CL_PROGRAM_BINARY_TYPE_NONE 0x0 #define CL_PROGRAM_BINARY_TYPE_COMPILED_OBJECT 0x1 #define CL_PROGRAM_BINARY_TYPE_LIBRARY 0x2 #define CL_PROGRAM_BINARY_TYPE_EXECUTABLE 0x4 #endif /* cl_build_status */ #define CL_BUILD_SUCCESS 0 #define CL_BUILD_NONE -1 #define CL_BUILD_ERROR -2 #define CL_BUILD_IN_PROGRESS -3 /* cl_kernel_info */ #define CL_KERNEL_FUNCTION_NAME 0x1190 #define CL_KERNEL_NUM_ARGS 0x1191 #define CL_KERNEL_REFERENCE_COUNT 0x1192 #define CL_KERNEL_CONTEXT 0x1193 #define CL_KERNEL_PROGRAM 0x1194 #ifdef CL_VERSION_1_2 #define CL_KERNEL_ATTRIBUTES 0x1195 #endif #ifdef CL_VERSION_1_2 /* cl_kernel_arg_info */ #define CL_KERNEL_ARG_ADDRESS_QUALIFIER 0x1196 #define CL_KERNEL_ARG_ACCESS_QUALIFIER 0x1197 #define CL_KERNEL_ARG_TYPE_NAME 0x1198 #define CL_KERNEL_ARG_TYPE_QUALIFIER 0x1199 #define CL_KERNEL_ARG_NAME 0x119A #endif #ifdef CL_VERSION_1_2 /* cl_kernel_arg_address_qualifier */ #define CL_KERNEL_ARG_ADDRESS_GLOBAL 0x119B #define CL_KERNEL_ARG_ADDRESS_LOCAL 0x119C #define CL_KERNEL_ARG_ADDRESS_CONSTANT 0x119D #define CL_KERNEL_ARG_ADDRESS_PRIVATE 0x119E #endif #ifdef CL_VERSION_1_2 /* cl_kernel_arg_access_qualifier */ #define CL_KERNEL_ARG_ACCESS_READ_ONLY 0x11A0 #define CL_KERNEL_ARG_ACCESS_WRITE_ONLY 0x11A1 #define CL_KERNEL_ARG_ACCESS_READ_WRITE 0x11A2 #define CL_KERNEL_ARG_ACCESS_NONE 0x11A3 #endif #ifdef CL_VERSION_1_2 /* cl_kernel_arg_type_qualifier */ #define CL_KERNEL_ARG_TYPE_NONE 0 #define CL_KERNEL_ARG_TYPE_CONST (1 << 0) #define CL_KERNEL_ARG_TYPE_RESTRICT (1 << 1) #define CL_KERNEL_ARG_TYPE_VOLATILE (1 << 2) #ifdef CL_VERSION_2_0 #define CL_KERNEL_ARG_TYPE_PIPE (1 << 3) #endif #endif /* cl_kernel_work_group_info */ #define CL_KERNEL_WORK_GROUP_SIZE 0x11B0 #define CL_KERNEL_COMPILE_WORK_GROUP_SIZE 0x11B1 #define CL_KERNEL_LOCAL_MEM_SIZE 0x11B2 #define CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE 0x11B3 #define CL_KERNEL_PRIVATE_MEM_SIZE 0x11B4 #ifdef CL_VERSION_1_2 #define CL_KERNEL_GLOBAL_WORK_SIZE 0x11B5 #endif #ifdef CL_VERSION_2_1 /* cl_kernel_sub_group_info */ #define CL_KERNEL_MAX_SUB_GROUP_SIZE_FOR_NDRANGE 0x2033 #define CL_KERNEL_SUB_GROUP_COUNT_FOR_NDRANGE 0x2034 #define CL_KERNEL_LOCAL_SIZE_FOR_SUB_GROUP_COUNT 0x11B8 #define CL_KERNEL_MAX_NUM_SUB_GROUPS 0x11B9 #define CL_KERNEL_COMPILE_NUM_SUB_GROUPS 0x11BA #endif #ifdef CL_VERSION_2_0 /* cl_kernel_exec_info */ #define CL_KERNEL_EXEC_INFO_SVM_PTRS 0x11B6 #define CL_KERNEL_EXEC_INFO_SVM_FINE_GRAIN_SYSTEM 0x11B7 #endif /* cl_event_info */ #define CL_EVENT_COMMAND_QUEUE 0x11D0 #define CL_EVENT_COMMAND_TYPE 0x11D1 #define CL_EVENT_REFERENCE_COUNT 0x11D2 #define CL_EVENT_COMMAND_EXECUTION_STATUS 0x11D3 #ifdef CL_VERSION_1_1 #define CL_EVENT_CONTEXT 0x11D4 #endif /* cl_command_type */ #define CL_COMMAND_NDRANGE_KERNEL 0x11F0 #define CL_COMMAND_TASK 0x11F1 #define CL_COMMAND_NATIVE_KERNEL 0x11F2 #define CL_COMMAND_READ_BUFFER 0x11F3 #define CL_COMMAND_WRITE_BUFFER 0x11F4 #define CL_COMMAND_COPY_BUFFER 0x11F5 #define CL_COMMAND_READ_IMAGE 0x11F6 #define CL_COMMAND_WRITE_IMAGE 0x11F7 #define CL_COMMAND_COPY_IMAGE 0x11F8 #define CL_COMMAND_COPY_IMAGE_TO_BUFFER 0x11F9 #define CL_COMMAND_COPY_BUFFER_TO_IMAGE 0x11FA #define CL_COMMAND_MAP_BUFFER 0x11FB #define CL_COMMAND_MAP_IMAGE 0x11FC #define CL_COMMAND_UNMAP_MEM_OBJECT 0x11FD #define CL_COMMAND_MARKER 0x11FE #define CL_COMMAND_ACQUIRE_GL_OBJECTS 0x11FF #define CL_COMMAND_RELEASE_GL_OBJECTS 0x1200 #ifdef CL_VERSION_1_1 #define CL_COMMAND_READ_BUFFER_RECT 0x1201 #define CL_COMMAND_WRITE_BUFFER_RECT 0x1202 #define CL_COMMAND_COPY_BUFFER_RECT 0x1203 #define CL_COMMAND_USER 0x1204 #endif #ifdef CL_VERSION_1_2 #define CL_COMMAND_BARRIER 0x1205 #define CL_COMMAND_MIGRATE_MEM_OBJECTS 0x1206 #define CL_COMMAND_FILL_BUFFER 0x1207 #define CL_COMMAND_FILL_IMAGE 0x1208 #endif #ifdef CL_VERSION_2_0 #define CL_COMMAND_SVM_FREE 0x1209 #define CL_COMMAND_SVM_MEMCPY 0x120A #define CL_COMMAND_SVM_MEMFILL 0x120B #define CL_COMMAND_SVM_MAP 0x120C #define CL_COMMAND_SVM_UNMAP 0x120D #endif #ifdef CL_VERSION_3_0 #define CL_COMMAND_SVM_MIGRATE_MEM 0x120E #endif /* command execution status */ #define CL_COMPLETE 0x0 #define CL_RUNNING 0x1 #define CL_SUBMITTED 0x2 #define CL_QUEUED 0x3 /* cl_buffer_create_type */ #ifdef CL_VERSION_1_1 #define CL_BUFFER_CREATE_TYPE_REGION 0x1220 #endif /* cl_profiling_info */ #define CL_PROFILING_COMMAND_QUEUED 0x1280 #define CL_PROFILING_COMMAND_SUBMIT 0x1281 #define CL_PROFILING_COMMAND_START 0x1282 #define CL_PROFILING_COMMAND_END 0x1283 #ifdef CL_VERSION_2_0 #define CL_PROFILING_COMMAND_COMPLETE 0x1284 #endif /* cl_device_atomic_capabilities - bitfield */ #ifdef CL_VERSION_3_0 #define CL_DEVICE_ATOMIC_ORDER_RELAXED (1 << 0) #define CL_DEVICE_ATOMIC_ORDER_ACQ_REL (1 << 1) #define CL_DEVICE_ATOMIC_ORDER_SEQ_CST (1 << 2) #define CL_DEVICE_ATOMIC_SCOPE_WORK_ITEM (1 << 3) #define CL_DEVICE_ATOMIC_SCOPE_WORK_GROUP (1 << 4) #define CL_DEVICE_ATOMIC_SCOPE_DEVICE (1 << 5) #define CL_DEVICE_ATOMIC_SCOPE_ALL_DEVICES (1 << 6) #endif /* cl_device_device_enqueue_capabilities - bitfield */ #ifdef CL_VERSION_3_0 #define CL_DEVICE_QUEUE_SUPPORTED (1 << 0) #define CL_DEVICE_QUEUE_REPLACEABLE_DEFAULT (1 << 1) #endif /* cl_khronos_vendor_id */ #define CL_KHRONOS_VENDOR_ID_CODEPLAY 0x10004 #ifdef CL_VERSION_3_0 /* cl_version */ #define CL_VERSION_MAJOR_BITS (10) #define CL_VERSION_MINOR_BITS (10) #define CL_VERSION_PATCH_BITS (12) #define CL_VERSION_MAJOR_MASK ((1 << CL_VERSION_MAJOR_BITS) - 1) #define CL_VERSION_MINOR_MASK ((1 << CL_VERSION_MINOR_BITS) - 1) #define CL_VERSION_PATCH_MASK ((1 << CL_VERSION_PATCH_BITS) - 1) #define CL_VERSION_MAJOR(version) \ ((version) >> (CL_VERSION_MINOR_BITS + CL_VERSION_PATCH_BITS)) #define CL_VERSION_MINOR(version) \ (((version) >> CL_VERSION_PATCH_BITS) & CL_VERSION_MINOR_MASK) #define CL_VERSION_PATCH(version) ((version) & CL_VERSION_PATCH_MASK) #define CL_MAKE_VERSION(major, minor, patch) \ ((((major) & CL_VERSION_MAJOR_MASK) \ << (CL_VERSION_MINOR_BITS + CL_VERSION_PATCH_BITS)) | \ (((minor) & CL_VERSION_MINOR_MASK) << CL_VERSION_PATCH_BITS) | \ ((patch) & CL_VERSION_PATCH_MASK)) #endif /********************************************************************************************************/ /* CL_NO_PROTOTYPES implies CL_NO_CORE_PROTOTYPES: */ #if defined(CL_NO_PROTOTYPES) && !defined(CL_NO_CORE_PROTOTYPES) #define CL_NO_CORE_PROTOTYPES #endif #if !defined(CL_NO_CORE_PROTOTYPES) /* Platform API */ extern CL_API_ENTRY cl_int CL_API_CALL clGetPlatformIDs(cl_uint num_entries, cl_platform_id * platforms, cl_uint * num_platforms) CL_API_SUFFIX__VERSION_1_0; extern CL_API_ENTRY cl_int CL_API_CALL clGetPlatformInfo(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; /* Device APIs */ extern CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDs(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; extern CL_API_ENTRY cl_int CL_API_CALL clGetDeviceInfo(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; #ifdef CL_VERSION_1_2 extern CL_API_ENTRY cl_int CL_API_CALL clCreateSubDevices(cl_device_id in_device, const cl_device_partition_property * properties, cl_uint num_devices, cl_device_id * out_devices, cl_uint * num_devices_ret) CL_API_SUFFIX__VERSION_1_2; extern CL_API_ENTRY cl_int CL_API_CALL clRetainDevice(cl_device_id device) CL_API_SUFFIX__VERSION_1_2; extern CL_API_ENTRY cl_int CL_API_CALL clReleaseDevice(cl_device_id device) CL_API_SUFFIX__VERSION_1_2; #endif #ifdef CL_VERSION_2_1 extern CL_API_ENTRY cl_int CL_API_CALL clSetDefaultDeviceCommandQueue(cl_context context, cl_device_id device, cl_command_queue command_queue) CL_API_SUFFIX__VERSION_2_1; extern CL_API_ENTRY cl_int CL_API_CALL clGetDeviceAndHostTimer(cl_device_id device, cl_ulong* device_timestamp, cl_ulong* host_timestamp) CL_API_SUFFIX__VERSION_2_1; extern CL_API_ENTRY cl_int CL_API_CALL clGetHostTimer(cl_device_id device, cl_ulong * host_timestamp) CL_API_SUFFIX__VERSION_2_1; #endif /* Context APIs */ extern CL_API_ENTRY cl_context CL_API_CALL clCreateContext(const cl_context_properties * properties, cl_uint num_devices, const cl_device_id * devices, void (CL_CALLBACK * pfn_notify)(const char * errinfo, const void * private_info, size_t cb, void * user_data), void * user_data, cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0; extern CL_API_ENTRY cl_context CL_API_CALL clCreateContextFromType(const cl_context_properties * properties, cl_device_type device_type, void (CL_CALLBACK * pfn_notify)(const char * errinfo, const void * private_info, size_t cb, void * user_data), void * user_data, cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0; extern CL_API_ENTRY cl_int CL_API_CALL clRetainContext(cl_context context) CL_API_SUFFIX__VERSION_1_0; extern CL_API_ENTRY cl_int CL_API_CALL clReleaseContext(cl_context context) CL_API_SUFFIX__VERSION_1_0; extern CL_API_ENTRY cl_int CL_API_CALL clGetContextInfo(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; #ifdef CL_VERSION_3_0 extern CL_API_ENTRY cl_int CL_API_CALL clSetContextDestructorCallback(cl_context context, void (CL_CALLBACK* pfn_notify)(cl_context context, void* user_data), void* user_data) CL_API_SUFFIX__VERSION_3_0; #endif /* Command Queue APIs */ #ifdef CL_VERSION_2_0 extern CL_API_ENTRY cl_command_queue CL_API_CALL clCreateCommandQueueWithProperties(cl_context context, cl_device_id device, const cl_queue_properties * properties, cl_int * errcode_ret) CL_API_SUFFIX__VERSION_2_0; #endif extern CL_API_ENTRY cl_int CL_API_CALL clRetainCommandQueue(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0; extern CL_API_ENTRY cl_int CL_API_CALL clReleaseCommandQueue(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0; extern CL_API_ENTRY cl_int CL_API_CALL clGetCommandQueueInfo(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; /* Memory Object APIs */ extern CL_API_ENTRY cl_mem CL_API_CALL clCreateBuffer(cl_context context, cl_mem_flags flags, size_t size, void * host_ptr, cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0; #ifdef CL_VERSION_1_1 extern CL_API_ENTRY cl_mem CL_API_CALL clCreateSubBuffer(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; #endif #ifdef CL_VERSION_1_2 extern CL_API_ENTRY cl_mem CL_API_CALL clCreateImage(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; #endif #ifdef CL_VERSION_2_0 extern CL_API_ENTRY cl_mem CL_API_CALL clCreatePipe(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; #endif #ifdef CL_VERSION_3_0 extern CL_API_ENTRY cl_mem CL_API_CALL clCreateBufferWithProperties(cl_context context, const cl_mem_properties * properties, cl_mem_flags flags, size_t size, void * host_ptr, cl_int * errcode_ret) CL_API_SUFFIX__VERSION_3_0; extern CL_API_ENTRY cl_mem CL_API_CALL clCreateImageWithProperties(cl_context context, const cl_mem_properties * properties, 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_3_0; #endif extern CL_API_ENTRY cl_int CL_API_CALL clRetainMemObject(cl_mem memobj) CL_API_SUFFIX__VERSION_1_0; extern CL_API_ENTRY cl_int CL_API_CALL clReleaseMemObject(cl_mem memobj) CL_API_SUFFIX__VERSION_1_0; extern CL_API_ENTRY cl_int CL_API_CALL clGetSupportedImageFormats(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; extern CL_API_ENTRY cl_int CL_API_CALL clGetMemObjectInfo(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; extern CL_API_ENTRY cl_int CL_API_CALL clGetImageInfo(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; #ifdef CL_VERSION_2_0 extern CL_API_ENTRY cl_int CL_API_CALL clGetPipeInfo(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; #endif #ifdef CL_VERSION_1_1 extern CL_API_ENTRY cl_int CL_API_CALL clSetMemObjectDestructorCallback(cl_mem memobj, void (CL_CALLBACK * pfn_notify)(cl_mem memobj, void * user_data), void * user_data) CL_API_SUFFIX__VERSION_1_1; #endif /* SVM Allocation APIs */ #ifdef CL_VERSION_2_0 extern CL_API_ENTRY void * CL_API_CALL clSVMAlloc(cl_context context, cl_svm_mem_flags flags, size_t size, cl_uint alignment) CL_API_SUFFIX__VERSION_2_0; extern CL_API_ENTRY void CL_API_CALL clSVMFree(cl_context context, void * svm_pointer) CL_API_SUFFIX__VERSION_2_0; #endif /* Sampler APIs */ #ifdef CL_VERSION_2_0 extern CL_API_ENTRY cl_sampler CL_API_CALL clCreateSamplerWithProperties(cl_context context, const cl_sampler_properties * sampler_properties, cl_int * errcode_ret) CL_API_SUFFIX__VERSION_2_0; #endif extern CL_API_ENTRY cl_int CL_API_CALL clRetainSampler(cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0; extern CL_API_ENTRY cl_int CL_API_CALL clReleaseSampler(cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0; extern CL_API_ENTRY cl_int CL_API_CALL clGetSamplerInfo(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 */ extern CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithSource(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 clCreateProgramWithBinary(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; #ifdef CL_VERSION_1_2 extern CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithBuiltInKernels(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; #endif #ifdef CL_VERSION_2_1 extern CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithIL(cl_context context, const void* il, size_t length, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_1; #endif extern CL_API_ENTRY cl_int CL_API_CALL clRetainProgram(cl_program program) CL_API_SUFFIX__VERSION_1_0; extern CL_API_ENTRY cl_int CL_API_CALL clReleaseProgram(cl_program program) CL_API_SUFFIX__VERSION_1_0; extern CL_API_ENTRY cl_int CL_API_CALL clBuildProgram(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; #ifdef CL_VERSION_1_2 extern CL_API_ENTRY cl_int CL_API_CALL clCompileProgram(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; extern CL_API_ENTRY cl_program CL_API_CALL clLinkProgram(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; #endif #ifdef CL_VERSION_2_2 extern CL_API_ENTRY CL_API_PREFIX__VERSION_2_2_DEPRECATED cl_int CL_API_CALL clSetProgramReleaseCallback(cl_program program, void (CL_CALLBACK * pfn_notify)(cl_program program, void * user_data), void * user_data) CL_API_SUFFIX__VERSION_2_2_DEPRECATED; extern CL_API_ENTRY cl_int CL_API_CALL clSetProgramSpecializationConstant(cl_program program, cl_uint spec_id, size_t spec_size, const void* spec_value) CL_API_SUFFIX__VERSION_2_2; #endif #ifdef CL_VERSION_1_2 extern CL_API_ENTRY cl_int CL_API_CALL clUnloadPlatformCompiler(cl_platform_id platform) CL_API_SUFFIX__VERSION_1_2; #endif extern CL_API_ENTRY cl_int CL_API_CALL clGetProgramInfo(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; extern CL_API_ENTRY cl_int CL_API_CALL clGetProgramBuildInfo(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 */ extern CL_API_ENTRY cl_kernel CL_API_CALL clCreateKernel(cl_program program, const char * kernel_name, cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0; extern CL_API_ENTRY cl_int CL_API_CALL clCreateKernelsInProgram(cl_program program, cl_uint num_kernels, cl_kernel * kernels, cl_uint * num_kernels_ret) CL_API_SUFFIX__VERSION_1_0; #ifdef CL_VERSION_2_1 extern CL_API_ENTRY cl_kernel CL_API_CALL clCloneKernel(cl_kernel source_kernel, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_1; #endif extern CL_API_ENTRY cl_int CL_API_CALL clRetainKernel(cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0; extern CL_API_ENTRY cl_int CL_API_CALL clReleaseKernel(cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0; extern CL_API_ENTRY cl_int CL_API_CALL clSetKernelArg(cl_kernel kernel, cl_uint arg_index, size_t arg_size, const void * arg_value) CL_API_SUFFIX__VERSION_1_0; #ifdef CL_VERSION_2_0 extern CL_API_ENTRY cl_int CL_API_CALL clSetKernelArgSVMPointer(cl_kernel kernel, cl_uint arg_index, const void * arg_value) CL_API_SUFFIX__VERSION_2_0; extern CL_API_ENTRY cl_int CL_API_CALL clSetKernelExecInfo(cl_kernel kernel, cl_kernel_exec_info param_name, size_t param_value_size, const void * param_value) CL_API_SUFFIX__VERSION_2_0; #endif extern CL_API_ENTRY cl_int CL_API_CALL clGetKernelInfo(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; #ifdef CL_VERSION_1_2 extern CL_API_ENTRY cl_int CL_API_CALL clGetKernelArgInfo(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; #endif extern CL_API_ENTRY cl_int CL_API_CALL clGetKernelWorkGroupInfo(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; #ifdef CL_VERSION_2_1 extern CL_API_ENTRY cl_int CL_API_CALL clGetKernelSubGroupInfo(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_1; #endif /* Event Object APIs */ extern CL_API_ENTRY cl_int CL_API_CALL clWaitForEvents(cl_uint num_events, const cl_event * event_list) CL_API_SUFFIX__VERSION_1_0; extern CL_API_ENTRY cl_int CL_API_CALL clGetEventInfo(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; #ifdef CL_VERSION_1_1 extern CL_API_ENTRY cl_event CL_API_CALL clCreateUserEvent(cl_context context, cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_1; #endif extern CL_API_ENTRY cl_int CL_API_CALL clRetainEvent(cl_event event) CL_API_SUFFIX__VERSION_1_0; extern CL_API_ENTRY cl_int CL_API_CALL clReleaseEvent(cl_event event) CL_API_SUFFIX__VERSION_1_0; #ifdef CL_VERSION_1_1 extern CL_API_ENTRY cl_int CL_API_CALL clSetUserEventStatus(cl_event event, cl_int execution_status) CL_API_SUFFIX__VERSION_1_1; extern CL_API_ENTRY cl_int CL_API_CALL clSetEventCallback(cl_event event, cl_int command_exec_callback_type, void (CL_CALLBACK * pfn_notify)(cl_event event, cl_int event_command_status, void * user_data), void * user_data) CL_API_SUFFIX__VERSION_1_1; #endif /* Profiling APIs */ extern CL_API_ENTRY cl_int CL_API_CALL clGetEventProfilingInfo(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 */ extern CL_API_ENTRY cl_int CL_API_CALL clFlush(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0; extern CL_API_ENTRY cl_int CL_API_CALL clFinish(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0; /* Enqueued Commands APIs */ extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadBuffer(cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_read, size_t offset, size_t size, void * ptr, cl_uint num_events_in_wait_list, const cl_event * event_wait_list, cl_event * event) CL_API_SUFFIX__VERSION_1_0; #ifdef CL_VERSION_1_1 extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadBufferRect(cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_read, const size_t * buffer_origin, const size_t * host_origin, 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; #endif extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteBuffer(cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_write, size_t offset, size_t size, 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; #ifdef CL_VERSION_1_1 extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteBufferRect(cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_write, const size_t * buffer_origin, const size_t * host_origin, 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; #endif #ifdef CL_VERSION_1_2 extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueFillBuffer(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; #endif extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBuffer(cl_command_queue command_queue, cl_mem src_buffer, cl_mem dst_buffer, size_t src_offset, size_t dst_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_0; #ifdef CL_VERSION_1_1 extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBufferRect(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; #endif extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadImage(cl_command_queue command_queue, cl_mem image, cl_bool blocking_read, const size_t * origin, const size_t * region, 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; extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteImage(cl_command_queue command_queue, cl_mem image, cl_bool blocking_write, const size_t * origin, const size_t * region, 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; #ifdef CL_VERSION_1_2 extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueFillImage(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; #endif extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyImage(cl_command_queue command_queue, cl_mem src_image, cl_mem dst_image, const size_t * src_origin, const size_t * dst_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_0; extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyImageToBuffer(cl_command_queue command_queue, cl_mem src_image, cl_mem dst_buffer, const size_t * src_origin, const size_t * region, 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; extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBufferToImage(cl_command_queue command_queue, cl_mem src_buffer, cl_mem dst_image, size_t src_offset, const size_t * dst_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_0; extern CL_API_ENTRY void * CL_API_CALL clEnqueueMapBuffer(cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_map, cl_map_flags map_flags, size_t offset, size_t size, 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; extern CL_API_ENTRY void * CL_API_CALL clEnqueueMapImage(cl_command_queue command_queue, cl_mem image, cl_bool blocking_map, cl_map_flags map_flags, const size_t * origin, const size_t * region, 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; extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueUnmapMemObject(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; #ifdef CL_VERSION_1_2 extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueMigrateMemObjects(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; #endif extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueNDRangeKernel(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; extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueNativeKernel(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; #ifdef CL_VERSION_1_2 extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueMarkerWithWaitList(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; extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueBarrierWithWaitList(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; #endif #ifdef CL_VERSION_2_0 extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMFree(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; extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMemcpy(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; extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMemFill(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; extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMap(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; extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMUnmap(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; #endif #ifdef CL_VERSION_2_1 extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMigrateMem(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; #endif #ifdef CL_VERSION_1_2 /* Extension function access * * Returns the extension function address for the given function name, * or NULL if a valid function can not be found. The client must * check to make sure the address is not NULL, before using or * calling the returned function address. */ extern CL_API_ENTRY void * CL_API_CALL clGetExtensionFunctionAddressForPlatform(cl_platform_id platform, const char * func_name) CL_API_SUFFIX__VERSION_1_2; #endif #ifdef CL_USE_DEPRECATED_OPENCL_1_0_APIS /* * WARNING: * This API introduces mutable state into the OpenCL implementation. It has been REMOVED * to better facilitate thread safety. The 1.0 API is not thread safe. It is not tested by the * OpenCL 1.1 conformance test, and consequently may not work or may not work dependably. * It is likely to be non-performant. Use of this API is not advised. Use at your own risk. * * Software developers previously relying on this API are instructed to set the command queue * properties when creating the queue, instead. */ 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_DEPRECATED; #endif /* CL_USE_DEPRECATED_OPENCL_1_0_APIS */ /* Deprecated OpenCL 1.1 APIs */ extern CL_API_ENTRY CL_API_PREFIX__VERSION_1_1_DEPRECATED cl_mem CL_API_CALL clCreateImage2D(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_1_DEPRECATED; extern CL_API_ENTRY CL_API_PREFIX__VERSION_1_1_DEPRECATED cl_mem CL_API_CALL clCreateImage3D(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_1_DEPRECATED; extern CL_API_ENTRY CL_API_PREFIX__VERSION_1_1_DEPRECATED cl_int CL_API_CALL clEnqueueMarker(cl_command_queue command_queue, cl_event * event) CL_API_SUFFIX__VERSION_1_1_DEPRECATED; extern CL_API_ENTRY CL_API_PREFIX__VERSION_1_1_DEPRECATED cl_int CL_API_CALL clEnqueueWaitForEvents(cl_command_queue command_queue, cl_uint num_events, const cl_event * event_list) CL_API_SUFFIX__VERSION_1_1_DEPRECATED; extern CL_API_ENTRY CL_API_PREFIX__VERSION_1_1_DEPRECATED cl_int CL_API_CALL clEnqueueBarrier(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_1_DEPRECATED; extern CL_API_ENTRY CL_API_PREFIX__VERSION_1_1_DEPRECATED cl_int CL_API_CALL clUnloadCompiler(void) CL_API_SUFFIX__VERSION_1_1_DEPRECATED; extern CL_API_ENTRY CL_API_PREFIX__VERSION_1_1_DEPRECATED void * CL_API_CALL clGetExtensionFunctionAddress(const char * func_name) CL_API_SUFFIX__VERSION_1_1_DEPRECATED; /* Deprecated OpenCL 2.0 APIs */ extern CL_API_ENTRY CL_API_PREFIX__VERSION_1_2_DEPRECATED cl_command_queue CL_API_CALL clCreateCommandQueue(cl_context context, cl_device_id device, cl_command_queue_properties properties, cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_2_DEPRECATED; extern CL_API_ENTRY CL_API_PREFIX__VERSION_1_2_DEPRECATED cl_sampler CL_API_CALL clCreateSampler(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_2_DEPRECATED; extern CL_API_ENTRY CL_API_PREFIX__VERSION_1_2_DEPRECATED cl_int CL_API_CALL clEnqueueTask(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_2_DEPRECATED; #endif /* !defined(CL_NO_CORE_PROTOTYPES) */ #ifdef __cplusplus } #endif #endif /* __OPENCL_CL_H */ ocl-icd-2.3.3/khronos-headers/CL/cl_d3d10.h000066400000000000000000000165631477331540600201120ustar00rootroot00000000000000/******************************************************************************* * Copyright (c) 2008-2023 The Khronos Group Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. ******************************************************************************/ #ifndef OPENCL_CL_D3D10_H_ #define OPENCL_CL_D3D10_H_ /* ** This header is generated from the Khronos OpenCL XML API Registry. */ #if defined(_MSC_VER) #if _MSC_VER >=1500 #pragma warning( push ) #pragma warning( disable : 4201 ) #pragma warning( disable : 5105 ) #endif #endif #include #if defined(_MSC_VER) #if _MSC_VER >=1500 #pragma warning( pop ) #endif #endif #include /* CL_NO_PROTOTYPES implies CL_NO_EXTENSION_PROTOTYPES: */ #if defined(CL_NO_PROTOTYPES) && !defined(CL_NO_EXTENSION_PROTOTYPES) #define CL_NO_EXTENSION_PROTOTYPES #endif /* CL_NO_EXTENSION_PROTOTYPES implies CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES and CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES: */ #if defined(CL_NO_EXTENSION_PROTOTYPES) && \ !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) #define CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES #endif #if defined(CL_NO_EXTENSION_PROTOTYPES) && \ !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) #define CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES #endif #ifdef __cplusplus extern "C" { #endif /*************************************************************** * cl_khr_d3d10_sharing ***************************************************************/ #define cl_khr_d3d10_sharing 1 #define CL_KHR_D3D10_SHARING_EXTENSION_NAME \ "cl_khr_d3d10_sharing" typedef cl_uint cl_d3d10_device_source_khr; typedef cl_uint cl_d3d10_device_set_khr; /* Error codes */ #define CL_INVALID_D3D10_DEVICE_KHR -1002 #define CL_INVALID_D3D10_RESOURCE_KHR -1003 #define CL_D3D10_RESOURCE_ALREADY_ACQUIRED_KHR -1004 #define CL_D3D10_RESOURCE_NOT_ACQUIRED_KHR -1005 /* cl_d3d10_device_source_khr */ #define CL_D3D10_DEVICE_KHR 0x4010 #define CL_D3D10_DXGI_ADAPTER_KHR 0x4011 /* cl_d3d10_device_set_khr */ #define CL_PREFERRED_DEVICES_FOR_D3D10_KHR 0x4012 #define CL_ALL_DEVICES_FOR_D3D10_KHR 0x4013 /* cl_context_info */ #define CL_CONTEXT_D3D10_DEVICE_KHR 0x4014 #define CL_CONTEXT_D3D10_PREFER_SHARED_RESOURCES_KHR 0x402C /* cl_mem_info */ #define CL_MEM_D3D10_RESOURCE_KHR 0x4015 /* cl_image_info */ #define CL_IMAGE_D3D10_SUBRESOURCE_KHR 0x4016 /* cl_command_type */ #define CL_COMMAND_ACQUIRE_D3D10_OBJECTS_KHR 0x4017 #define CL_COMMAND_RELEASE_D3D10_OBJECTS_KHR 0x4018 typedef cl_int (CL_API_CALL * clGetDeviceIDsFromD3D10KHR_fn)( cl_platform_id platform, cl_d3d10_device_source_khr d3d_device_source, void* d3d_object, cl_d3d10_device_set_khr d3d_device_set, cl_uint num_entries, cl_device_id* devices, cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_0; typedef cl_mem (CL_API_CALL * clCreateFromD3D10BufferKHR_fn)( cl_context context, cl_mem_flags flags, ID3D10Buffer* resource, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0; typedef cl_mem (CL_API_CALL * clCreateFromD3D10Texture2DKHR_fn)( cl_context context, cl_mem_flags flags, ID3D10Texture2D* resource, UINT subresource, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0; typedef cl_mem (CL_API_CALL * clCreateFromD3D10Texture3DKHR_fn)( cl_context context, cl_mem_flags flags, ID3D10Texture3D* resource, UINT subresource, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0; typedef cl_int (CL_API_CALL * clEnqueueAcquireD3D10ObjectsKHR_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 * clEnqueueReleaseD3D10ObjectsKHR_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; #if !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromD3D10KHR( cl_platform_id platform, cl_d3d10_device_source_khr d3d_device_source, void* d3d_object, cl_d3d10_device_set_khr d3d_device_set, cl_uint num_entries, cl_device_id* devices, cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_0; extern CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10BufferKHR( cl_context context, cl_mem_flags flags, ID3D10Buffer* resource, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0; extern CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture2DKHR( cl_context context, cl_mem_flags flags, ID3D10Texture2D* resource, UINT subresource, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0; extern CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture3DKHR( cl_context context, cl_mem_flags flags, ID3D10Texture3D* resource, UINT subresource, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0; extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D10ObjectsKHR( 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 clEnqueueReleaseD3D10ObjectsKHR( 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; #endif /* !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_intel_sharing_format_query_d3d10 ***************************************************************/ #define cl_intel_sharing_format_query_d3d10 1 #define CL_INTEL_SHARING_FORMAT_QUERY_D3D10_EXTENSION_NAME \ "cl_intel_sharing_format_query_d3d10" /* when cl_khr_d3d10_sharing is supported */ typedef cl_int (CL_API_CALL * clGetSupportedD3D10TextureFormatsINTEL_fn)( cl_context context, cl_mem_flags flags, cl_mem_object_type image_type, cl_uint num_entries, DXGI_FORMAT* d3d10_formats, cl_uint* num_texture_formats) ; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL clGetSupportedD3D10TextureFormatsINTEL( cl_context context, cl_mem_flags flags, cl_mem_object_type image_type, cl_uint num_entries, DXGI_FORMAT* d3d10_formats, cl_uint* num_texture_formats) ; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ #ifdef __cplusplus } #endif #endif /* OPENCL_CL_D3D10_H_ */ ocl-icd-2.3.3/khronos-headers/CL/cl_d3d11.h000066400000000000000000000166311477331540600201070ustar00rootroot00000000000000/******************************************************************************* * Copyright (c) 2008-2023 The Khronos Group Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. ******************************************************************************/ #ifndef OPENCL_CL_D3D11_H_ #define OPENCL_CL_D3D11_H_ /* ** This header is generated from the Khronos OpenCL XML API Registry. */ #if defined(_MSC_VER) #if _MSC_VER >=1500 #pragma warning( push ) #pragma warning( disable : 4201 ) #pragma warning( disable : 5105 ) #endif #endif #include #if defined(_MSC_VER) #if _MSC_VER >=1500 #pragma warning( pop ) #endif #endif #include /* CL_NO_PROTOTYPES implies CL_NO_EXTENSION_PROTOTYPES: */ #if defined(CL_NO_PROTOTYPES) && !defined(CL_NO_EXTENSION_PROTOTYPES) #define CL_NO_EXTENSION_PROTOTYPES #endif /* CL_NO_EXTENSION_PROTOTYPES implies CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES and CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES: */ #if defined(CL_NO_EXTENSION_PROTOTYPES) && \ !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) #define CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES #endif #if defined(CL_NO_EXTENSION_PROTOTYPES) && \ !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) #define CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES #endif #ifdef __cplusplus extern "C" { #endif /*************************************************************** * cl_khr_d3d11_sharing ***************************************************************/ #define cl_khr_d3d11_sharing 1 #define CL_KHR_D3D11_SHARING_EXTENSION_NAME \ "cl_khr_d3d11_sharing" typedef cl_uint cl_d3d11_device_source_khr; typedef cl_uint cl_d3d11_device_set_khr; /* Error codes */ #define CL_INVALID_D3D11_DEVICE_KHR -1006 #define CL_INVALID_D3D11_RESOURCE_KHR -1007 #define CL_D3D11_RESOURCE_ALREADY_ACQUIRED_KHR -1008 #define CL_D3D11_RESOURCE_NOT_ACQUIRED_KHR -1009 /* cl_d3d11_device_source_khr */ #define CL_D3D11_DEVICE_KHR 0x4019 #define CL_D3D11_DXGI_ADAPTER_KHR 0x401A /* cl_d3d11_device_set_khr */ #define CL_PREFERRED_DEVICES_FOR_D3D11_KHR 0x401B #define CL_ALL_DEVICES_FOR_D3D11_KHR 0x401C /* cl_context_info */ #define CL_CONTEXT_D3D11_DEVICE_KHR 0x401D #define CL_CONTEXT_D3D11_PREFER_SHARED_RESOURCES_KHR 0x402D /* cl_mem_info */ #define CL_MEM_D3D11_RESOURCE_KHR 0x401E /* cl_image_info */ #define CL_IMAGE_D3D11_SUBRESOURCE_KHR 0x401F /* cl_command_type */ #define CL_COMMAND_ACQUIRE_D3D11_OBJECTS_KHR 0x4020 #define CL_COMMAND_RELEASE_D3D11_OBJECTS_KHR 0x4021 typedef cl_int (CL_API_CALL * clGetDeviceIDsFromD3D11KHR_fn)( cl_platform_id platform, cl_d3d11_device_source_khr d3d_device_source, void* d3d_object, cl_d3d11_device_set_khr d3d_device_set, cl_uint num_entries, cl_device_id* devices, cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_2; typedef cl_mem (CL_API_CALL * clCreateFromD3D11BufferKHR_fn)( cl_context context, cl_mem_flags flags, ID3D11Buffer* resource, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; typedef cl_mem (CL_API_CALL * clCreateFromD3D11Texture2DKHR_fn)( cl_context context, cl_mem_flags flags, ID3D11Texture2D* resource, UINT subresource, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; typedef cl_mem (CL_API_CALL * clCreateFromD3D11Texture3DKHR_fn)( cl_context context, cl_mem_flags flags, ID3D11Texture3D* resource, UINT subresource, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; typedef cl_int (CL_API_CALL * clEnqueueAcquireD3D11ObjectsKHR_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_2; typedef cl_int (CL_API_CALL * clEnqueueReleaseD3D11ObjectsKHR_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_2; #if !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromD3D11KHR( cl_platform_id platform, cl_d3d11_device_source_khr d3d_device_source, void* d3d_object, cl_d3d11_device_set_khr d3d_device_set, cl_uint num_entries, cl_device_id* devices, cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_2; extern CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11BufferKHR( cl_context context, cl_mem_flags flags, ID3D11Buffer* resource, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; extern CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture2DKHR( cl_context context, cl_mem_flags flags, ID3D11Texture2D* resource, UINT subresource, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; extern CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture3DKHR( cl_context context, cl_mem_flags flags, ID3D11Texture3D* resource, UINT subresource, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D11ObjectsKHR( 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_2; extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseD3D11ObjectsKHR( 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_2; #endif /* !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_intel_sharing_format_query_d3d11 ***************************************************************/ #define cl_intel_sharing_format_query_d3d11 1 #define CL_INTEL_SHARING_FORMAT_QUERY_D3D11_EXTENSION_NAME \ "cl_intel_sharing_format_query_d3d11" /* when cl_khr_d3d11_sharing is supported */ typedef cl_int (CL_API_CALL * clGetSupportedD3D11TextureFormatsINTEL_fn)( cl_context context, cl_mem_flags flags, cl_mem_object_type image_type, cl_uint plane, cl_uint num_entries, DXGI_FORMAT* d3d11_formats, cl_uint* num_texture_formats) ; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL clGetSupportedD3D11TextureFormatsINTEL( cl_context context, cl_mem_flags flags, cl_mem_object_type image_type, cl_uint plane, cl_uint num_entries, DXGI_FORMAT* d3d11_formats, cl_uint* num_texture_formats) ; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ #ifdef __cplusplus } #endif #endif /* OPENCL_CL_D3D11_H_ */ ocl-icd-2.3.3/khronos-headers/CL/cl_dx9_media_sharing.h000066400000000000000000000264061477331540600226520ustar00rootroot00000000000000/******************************************************************************* * Copyright (c) 2008-2023 The Khronos Group Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. ******************************************************************************/ #ifndef OPENCL_CL_DX9_MEDIA_SHARING_H_ #define OPENCL_CL_DX9_MEDIA_SHARING_H_ /* ** This header is generated from the Khronos OpenCL XML API Registry. */ #if defined(_WIN32) #if defined(_MSC_VER) #if _MSC_VER >=1500 #pragma warning( push ) #pragma warning( disable : 4201 ) #pragma warning( disable : 5105 ) #endif #endif #include #if defined(_MSC_VER) #if _MSC_VER >=1500 #pragma warning( pop ) #endif #endif #endif #include /* CL_NO_PROTOTYPES implies CL_NO_EXTENSION_PROTOTYPES: */ #if defined(CL_NO_PROTOTYPES) && !defined(CL_NO_EXTENSION_PROTOTYPES) #define CL_NO_EXTENSION_PROTOTYPES #endif /* CL_NO_EXTENSION_PROTOTYPES implies CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES and CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES: */ #if defined(CL_NO_EXTENSION_PROTOTYPES) && \ !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) #define CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES #endif #if defined(CL_NO_EXTENSION_PROTOTYPES) && \ !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) #define CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES #endif #ifdef __cplusplus extern "C" { #endif /*************************************************************** * cl_khr_dx9_media_sharing ***************************************************************/ #define cl_khr_dx9_media_sharing 1 #define CL_KHR_DX9_MEDIA_SHARING_EXTENSION_NAME \ "cl_khr_dx9_media_sharing" typedef cl_uint cl_dx9_media_adapter_type_khr; typedef cl_uint cl_dx9_media_adapter_set_khr; #if defined(_WIN32) typedef struct _cl_dx9_surface_info_khr { IDirect3DSurface9* resource; HANDLE shared_handle; } cl_dx9_surface_info_khr; #endif /* defined(_WIN32) */ /* Error codes */ #define CL_INVALID_DX9_MEDIA_ADAPTER_KHR -1010 #define CL_INVALID_DX9_MEDIA_SURFACE_KHR -1011 #define CL_DX9_MEDIA_SURFACE_ALREADY_ACQUIRED_KHR -1012 #define CL_DX9_MEDIA_SURFACE_NOT_ACQUIRED_KHR -1013 /* cl_media_adapter_type_khr */ #define CL_ADAPTER_D3D9_KHR 0x2020 #define CL_ADAPTER_D3D9EX_KHR 0x2021 #define CL_ADAPTER_DXVA_KHR 0x2022 /* cl_media_adapter_set_khr */ #define CL_PREFERRED_DEVICES_FOR_DX9_MEDIA_ADAPTER_KHR 0x2023 #define CL_ALL_DEVICES_FOR_DX9_MEDIA_ADAPTER_KHR 0x2024 /* cl_context_info */ #define CL_CONTEXT_ADAPTER_D3D9_KHR 0x2025 #define CL_CONTEXT_ADAPTER_D3D9EX_KHR 0x2026 #define CL_CONTEXT_ADAPTER_DXVA_KHR 0x2027 /* cl_mem_info */ #define CL_MEM_DX9_MEDIA_ADAPTER_TYPE_KHR 0x2028 #define CL_MEM_DX9_MEDIA_SURFACE_INFO_KHR 0x2029 /* cl_image_info */ #define CL_IMAGE_DX9_MEDIA_PLANE_KHR 0x202A /* cl_command_type */ #define CL_COMMAND_ACQUIRE_DX9_MEDIA_SURFACES_KHR 0x202B #define CL_COMMAND_RELEASE_DX9_MEDIA_SURFACES_KHR 0x202C typedef cl_int (CL_API_CALL * clGetDeviceIDsFromDX9MediaAdapterKHR_fn)( cl_platform_id platform, cl_uint num_media_adapters, cl_dx9_media_adapter_type_khr* media_adapter_type, void* media_adapters, cl_dx9_media_adapter_set_khr media_adapter_set, cl_uint num_entries, cl_device_id* devices, cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_2; typedef cl_mem (CL_API_CALL * clCreateFromDX9MediaSurfaceKHR_fn)( cl_context context, cl_mem_flags flags, cl_dx9_media_adapter_type_khr adapter_type, void* surface_info, cl_uint plane, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; typedef cl_int (CL_API_CALL * clEnqueueAcquireDX9MediaSurfacesKHR_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_2; typedef cl_int (CL_API_CALL * clEnqueueReleaseDX9MediaSurfacesKHR_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_2; #if !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromDX9MediaAdapterKHR( cl_platform_id platform, cl_uint num_media_adapters, cl_dx9_media_adapter_type_khr* media_adapter_type, void* media_adapters, cl_dx9_media_adapter_set_khr media_adapter_set, cl_uint num_entries, cl_device_id* devices, cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_2; extern CL_API_ENTRY cl_mem CL_API_CALL clCreateFromDX9MediaSurfaceKHR( cl_context context, cl_mem_flags flags, cl_dx9_media_adapter_type_khr adapter_type, void* surface_info, cl_uint plane, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireDX9MediaSurfacesKHR( 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_2; extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseDX9MediaSurfacesKHR( 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_2; #endif /* !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_intel_dx9_media_sharing ***************************************************************/ #define cl_intel_dx9_media_sharing 1 #define CL_INTEL_DX9_MEDIA_SHARING_EXTENSION_NAME \ "cl_intel_dx9_media_sharing" typedef cl_uint cl_dx9_device_source_intel; typedef cl_uint cl_dx9_device_set_intel; /* Error codes */ #define CL_INVALID_DX9_DEVICE_INTEL -1010 #define CL_INVALID_DX9_RESOURCE_INTEL -1011 #define CL_DX9_RESOURCE_ALREADY_ACQUIRED_INTEL -1012 #define CL_DX9_RESOURCE_NOT_ACQUIRED_INTEL -1013 /* cl_dx9_device_source_intel */ #define CL_D3D9_DEVICE_INTEL 0x4022 #define CL_D3D9EX_DEVICE_INTEL 0x4070 #define CL_DXVA_DEVICE_INTEL 0x4071 /* cl_dx9_device_set_intel */ #define CL_PREFERRED_DEVICES_FOR_DX9_INTEL 0x4024 #define CL_ALL_DEVICES_FOR_DX9_INTEL 0x4025 /* cl_context_info */ #define CL_CONTEXT_D3D9_DEVICE_INTEL 0x4026 #define CL_CONTEXT_D3D9EX_DEVICE_INTEL 0x4072 #define CL_CONTEXT_DXVA_DEVICE_INTEL 0x4073 /* cl_mem_info */ #define CL_MEM_DX9_RESOURCE_INTEL 0x4027 #define CL_MEM_DX9_SHARED_HANDLE_INTEL 0x4074 /* cl_image_info */ #define CL_IMAGE_DX9_PLANE_INTEL 0x4075 /* cl_command_type */ #define CL_COMMAND_ACQUIRE_DX9_OBJECTS_INTEL 0x402A #define CL_COMMAND_RELEASE_DX9_OBJECTS_INTEL 0x402B typedef cl_int (CL_API_CALL * clGetDeviceIDsFromDX9INTEL_fn)( cl_platform_id platform, cl_dx9_device_source_intel dx9_device_source, void* dx9_object, cl_dx9_device_set_intel dx9_device_set, cl_uint num_entries, cl_device_id* devices, cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_1; typedef cl_mem (CL_API_CALL * clCreateFromDX9MediaSurfaceINTEL_fn)( cl_context context, cl_mem_flags flags, IDirect3DSurface9* resource, HANDLE sharedHandle, UINT plane, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_1; typedef cl_int (CL_API_CALL * clEnqueueAcquireDX9ObjectsINTEL_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_1; typedef cl_int (CL_API_CALL * clEnqueueReleaseDX9ObjectsINTEL_fn)( cl_command_queue command_queue, cl_uint num_objects, 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_1; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromDX9INTEL( cl_platform_id platform, cl_dx9_device_source_intel dx9_device_source, void* dx9_object, cl_dx9_device_set_intel dx9_device_set, cl_uint num_entries, cl_device_id* devices, cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_1; extern CL_API_ENTRY cl_mem CL_API_CALL clCreateFromDX9MediaSurfaceINTEL( cl_context context, cl_mem_flags flags, IDirect3DSurface9* resource, HANDLE sharedHandle, UINT plane, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_1; extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireDX9ObjectsINTEL( 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_1; extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseDX9ObjectsINTEL( cl_command_queue command_queue, cl_uint num_objects, 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_1; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_intel_sharing_format_query_dx9 ***************************************************************/ #define cl_intel_sharing_format_query_dx9 1 #define CL_INTEL_SHARING_FORMAT_QUERY_DX9_EXTENSION_NAME \ "cl_intel_sharing_format_query_dx9" /* when cl_khr_dx9_media_sharing or cl_intel_dx9_media_sharing is supported */ typedef cl_int (CL_API_CALL * clGetSupportedDX9MediaSurfaceFormatsINTEL_fn)( cl_context context, cl_mem_flags flags, cl_mem_object_type image_type, cl_uint plane, cl_uint num_entries, D3DFORMAT* dx9_formats, cl_uint* num_surface_formats) ; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL clGetSupportedDX9MediaSurfaceFormatsINTEL( cl_context context, cl_mem_flags flags, cl_mem_object_type image_type, cl_uint plane, cl_uint num_entries, D3DFORMAT* dx9_formats, cl_uint* num_surface_formats) ; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ #ifdef __cplusplus } #endif #endif /* OPENCL_CL_DX9_MEDIA_SHARING_H_ */ ocl-icd-2.3.3/khronos-headers/CL/cl_dx9_media_sharing_intel.h000066400000000000000000000016771477331540600240500ustar00rootroot00000000000000/******************************************************************************* * Copyright (c) 2008-2020 The Khronos Group Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. ******************************************************************************/ #include #pragma message("The Intel DX9 media sharing extensions have been moved into cl_dx9_media_sharing.h. Please include cl_dx9_media_sharing.h directly.") ocl-icd-2.3.3/khronos-headers/CL/cl_egl.h000066400000000000000000000124301477331540600200330ustar00rootroot00000000000000/******************************************************************************* * Copyright (c) 2008-2023 The Khronos Group Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. ******************************************************************************/ #ifndef OPENCL_CL_EGL_H_ #define OPENCL_CL_EGL_H_ /* ** This header is generated from the Khronos OpenCL XML API Registry. */ #include /* CL_NO_PROTOTYPES implies CL_NO_EXTENSION_PROTOTYPES: */ #if defined(CL_NO_PROTOTYPES) && !defined(CL_NO_EXTENSION_PROTOTYPES) #define CL_NO_EXTENSION_PROTOTYPES #endif /* CL_NO_EXTENSION_PROTOTYPES implies CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES and CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES: */ #if defined(CL_NO_EXTENSION_PROTOTYPES) && \ !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) #define CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES #endif #if defined(CL_NO_EXTENSION_PROTOTYPES) && \ !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) #define CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES #endif #ifdef __cplusplus extern "C" { #endif /*************************************************************** * cl_khr_egl_image ***************************************************************/ #define cl_khr_egl_image 1 #define CL_KHR_EGL_IMAGE_EXTENSION_NAME \ "cl_khr_egl_image" /* 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; /* properties passed to clCreateFromEGLImageKHR */ typedef intptr_t cl_egl_image_properties_khr; typedef 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) CL_API_SUFFIX__VERSION_1_0; typedef 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) CL_API_SUFFIX__VERSION_1_0; typedef 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) CL_API_SUFFIX__VERSION_1_0; #if !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) 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; 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; 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; #endif /* !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_khr_egl_event ***************************************************************/ #define cl_khr_egl_event 1 #define CL_KHR_EGL_EVENT_EXTENSION_NAME \ "cl_khr_egl_event" /* CLeglDisplayKHR is an opaque handle to an EGLDisplay */ /* type CLeglDisplayKHR */ /* CLeglSyncKHR is an opaque handle to an EGLSync object */ typedef void* CLeglSyncKHR; typedef cl_event (CL_API_CALL * clCreateEventFromEGLSyncKHR_fn)( cl_context context, CLeglSyncKHR sync, CLeglDisplayKHR display, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0; #if !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) 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; #endif /* !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ #ifdef __cplusplus } #endif #endif /* OPENCL_CL_EGL_H_ */ ocl-icd-2.3.3/khronos-headers/CL/cl_ext.h000066400000000000000000003506661477331540600201040ustar00rootroot00000000000000/******************************************************************************* * Copyright (c) 2008-2023 The Khronos Group Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. ******************************************************************************/ #ifndef OPENCL_CL_EXT_H_ #define OPENCL_CL_EXT_H_ /* ** This header is generated from the Khronos OpenCL XML API Registry. */ #include /* CL_NO_PROTOTYPES implies CL_NO_EXTENSION_PROTOTYPES: */ #if defined(CL_NO_PROTOTYPES) && !defined(CL_NO_EXTENSION_PROTOTYPES) #define CL_NO_EXTENSION_PROTOTYPES #endif /* CL_NO_EXTENSION_PROTOTYPES implies CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES and CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES: */ #if defined(CL_NO_EXTENSION_PROTOTYPES) && \ !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) #define CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES #endif #if defined(CL_NO_EXTENSION_PROTOTYPES) && \ !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) #define CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES #endif #ifdef __cplusplus extern "C" { #endif /*************************************************************** * cl_khr_command_buffer ***************************************************************/ #define cl_khr_command_buffer 1 #define CL_KHR_COMMAND_BUFFER_EXTENSION_NAME \ "cl_khr_command_buffer" typedef cl_bitfield cl_device_command_buffer_capabilities_khr; typedef struct _cl_command_buffer_khr* cl_command_buffer_khr; typedef cl_uint cl_sync_point_khr; typedef cl_uint cl_command_buffer_info_khr; typedef cl_uint cl_command_buffer_state_khr; typedef cl_properties cl_command_buffer_properties_khr; typedef cl_bitfield cl_command_buffer_flags_khr; typedef cl_properties cl_ndrange_kernel_command_properties_khr; typedef struct _cl_mutable_command_khr* cl_mutable_command_khr; /* cl_device_info */ #define CL_DEVICE_COMMAND_BUFFER_CAPABILITIES_KHR 0x12A9 #define CL_DEVICE_COMMAND_BUFFER_REQUIRED_QUEUE_PROPERTIES_KHR 0x12AA /* cl_device_command_buffer_capabilities_khr - bitfield */ #define CL_COMMAND_BUFFER_CAPABILITY_KERNEL_PRINTF_KHR (1 << 0) #define CL_COMMAND_BUFFER_CAPABILITY_DEVICE_SIDE_ENQUEUE_KHR (1 << 1) #define CL_COMMAND_BUFFER_CAPABILITY_SIMULTANEOUS_USE_KHR (1 << 2) #define CL_COMMAND_BUFFER_CAPABILITY_OUT_OF_ORDER_KHR (1 << 3) /* cl_command_buffer_properties_khr */ #define CL_COMMAND_BUFFER_FLAGS_KHR 0x1293 /* cl_command_buffer_flags_khr - bitfield */ #define CL_COMMAND_BUFFER_SIMULTANEOUS_USE_KHR (1 << 0) /* Error codes */ #define CL_INVALID_COMMAND_BUFFER_KHR -1138 #define CL_INVALID_SYNC_POINT_WAIT_LIST_KHR -1139 #define CL_INCOMPATIBLE_COMMAND_QUEUE_KHR -1140 /* cl_command_buffer_info_khr */ #define CL_COMMAND_BUFFER_QUEUES_KHR 0x1294 #define CL_COMMAND_BUFFER_NUM_QUEUES_KHR 0x1295 #define CL_COMMAND_BUFFER_REFERENCE_COUNT_KHR 0x1296 #define CL_COMMAND_BUFFER_STATE_KHR 0x1297 #define CL_COMMAND_BUFFER_PROPERTIES_ARRAY_KHR 0x1298 #define CL_COMMAND_BUFFER_CONTEXT_KHR 0x1299 /* cl_command_buffer_state_khr */ #define CL_COMMAND_BUFFER_STATE_RECORDING_KHR 0 #define CL_COMMAND_BUFFER_STATE_EXECUTABLE_KHR 1 #define CL_COMMAND_BUFFER_STATE_PENDING_KHR 2 #define CL_COMMAND_BUFFER_STATE_INVALID_KHR 3 /* cl_command_type */ #define CL_COMMAND_COMMAND_BUFFER_KHR 0x12A8 typedef cl_command_buffer_khr (CL_API_CALL * clCreateCommandBufferKHR_fn)( cl_uint num_queues, const cl_command_queue* queues, const cl_command_buffer_properties_khr* properties, cl_int* errcode_ret) ; typedef cl_int (CL_API_CALL * clFinalizeCommandBufferKHR_fn)( cl_command_buffer_khr command_buffer) ; typedef cl_int (CL_API_CALL * clRetainCommandBufferKHR_fn)( cl_command_buffer_khr command_buffer) ; typedef cl_int (CL_API_CALL * clReleaseCommandBufferKHR_fn)( cl_command_buffer_khr command_buffer) ; typedef cl_int (CL_API_CALL * clEnqueueCommandBufferKHR_fn)( cl_uint num_queues, cl_command_queue* queues, cl_command_buffer_khr command_buffer, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event) ; typedef cl_int (CL_API_CALL * clCommandBarrierWithWaitListKHR_fn)( cl_command_buffer_khr command_buffer, cl_command_queue command_queue, cl_uint num_sync_points_in_wait_list, const cl_sync_point_khr* sync_point_wait_list, cl_sync_point_khr* sync_point, cl_mutable_command_khr* mutable_handle) ; typedef cl_int (CL_API_CALL * clCommandCopyBufferKHR_fn)( cl_command_buffer_khr command_buffer, cl_command_queue command_queue, cl_mem src_buffer, cl_mem dst_buffer, size_t src_offset, size_t dst_offset, size_t size, cl_uint num_sync_points_in_wait_list, const cl_sync_point_khr* sync_point_wait_list, cl_sync_point_khr* sync_point, cl_mutable_command_khr* mutable_handle) ; typedef cl_int (CL_API_CALL * clCommandCopyBufferRectKHR_fn)( cl_command_buffer_khr command_buffer, 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_sync_points_in_wait_list, const cl_sync_point_khr* sync_point_wait_list, cl_sync_point_khr* sync_point, cl_mutable_command_khr* mutable_handle) ; typedef cl_int (CL_API_CALL * clCommandCopyBufferToImageKHR_fn)( cl_command_buffer_khr command_buffer, cl_command_queue command_queue, cl_mem src_buffer, cl_mem dst_image, size_t src_offset, const size_t* dst_origin, const size_t* region, cl_uint num_sync_points_in_wait_list, const cl_sync_point_khr* sync_point_wait_list, cl_sync_point_khr* sync_point, cl_mutable_command_khr* mutable_handle) ; typedef cl_int (CL_API_CALL * clCommandCopyImageKHR_fn)( cl_command_buffer_khr command_buffer, cl_command_queue command_queue, cl_mem src_image, cl_mem dst_image, const size_t* src_origin, const size_t* dst_origin, const size_t* region, cl_uint num_sync_points_in_wait_list, const cl_sync_point_khr* sync_point_wait_list, cl_sync_point_khr* sync_point, cl_mutable_command_khr* mutable_handle) ; typedef cl_int (CL_API_CALL * clCommandCopyImageToBufferKHR_fn)( cl_command_buffer_khr command_buffer, cl_command_queue command_queue, cl_mem src_image, cl_mem dst_buffer, const size_t* src_origin, const size_t* region, size_t dst_offset, cl_uint num_sync_points_in_wait_list, const cl_sync_point_khr* sync_point_wait_list, cl_sync_point_khr* sync_point, cl_mutable_command_khr* mutable_handle) ; typedef cl_int (CL_API_CALL * clCommandFillBufferKHR_fn)( cl_command_buffer_khr command_buffer, cl_command_queue command_queue, cl_mem buffer, const void* pattern, size_t pattern_size, size_t offset, size_t size, cl_uint num_sync_points_in_wait_list, const cl_sync_point_khr* sync_point_wait_list, cl_sync_point_khr* sync_point, cl_mutable_command_khr* mutable_handle) ; typedef cl_int (CL_API_CALL * clCommandFillImageKHR_fn)( cl_command_buffer_khr command_buffer, cl_command_queue command_queue, cl_mem image, const void* fill_color, const size_t* origin, const size_t* region, cl_uint num_sync_points_in_wait_list, const cl_sync_point_khr* sync_point_wait_list, cl_sync_point_khr* sync_point, cl_mutable_command_khr* mutable_handle) ; typedef cl_int (CL_API_CALL * clCommandNDRangeKernelKHR_fn)( cl_command_buffer_khr command_buffer, cl_command_queue command_queue, const cl_ndrange_kernel_command_properties_khr* properties, 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_sync_points_in_wait_list, const cl_sync_point_khr* sync_point_wait_list, cl_sync_point_khr* sync_point, cl_mutable_command_khr* mutable_handle) ; typedef cl_int (CL_API_CALL * clGetCommandBufferInfoKHR_fn)( cl_command_buffer_khr command_buffer, cl_command_buffer_info_khr param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret) ; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_command_buffer_khr CL_API_CALL clCreateCommandBufferKHR( cl_uint num_queues, const cl_command_queue* queues, const cl_command_buffer_properties_khr* properties, cl_int* errcode_ret) ; extern CL_API_ENTRY cl_int CL_API_CALL clFinalizeCommandBufferKHR( cl_command_buffer_khr command_buffer) ; extern CL_API_ENTRY cl_int CL_API_CALL clRetainCommandBufferKHR( cl_command_buffer_khr command_buffer) ; extern CL_API_ENTRY cl_int CL_API_CALL clReleaseCommandBufferKHR( cl_command_buffer_khr command_buffer) ; extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueCommandBufferKHR( cl_uint num_queues, cl_command_queue* queues, cl_command_buffer_khr command_buffer, 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 clCommandBarrierWithWaitListKHR( cl_command_buffer_khr command_buffer, cl_command_queue command_queue, cl_uint num_sync_points_in_wait_list, const cl_sync_point_khr* sync_point_wait_list, cl_sync_point_khr* sync_point, cl_mutable_command_khr* mutable_handle) ; extern CL_API_ENTRY cl_int CL_API_CALL clCommandCopyBufferKHR( cl_command_buffer_khr command_buffer, cl_command_queue command_queue, cl_mem src_buffer, cl_mem dst_buffer, size_t src_offset, size_t dst_offset, size_t size, cl_uint num_sync_points_in_wait_list, const cl_sync_point_khr* sync_point_wait_list, cl_sync_point_khr* sync_point, cl_mutable_command_khr* mutable_handle) ; extern CL_API_ENTRY cl_int CL_API_CALL clCommandCopyBufferRectKHR( cl_command_buffer_khr command_buffer, 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_sync_points_in_wait_list, const cl_sync_point_khr* sync_point_wait_list, cl_sync_point_khr* sync_point, cl_mutable_command_khr* mutable_handle) ; extern CL_API_ENTRY cl_int CL_API_CALL clCommandCopyBufferToImageKHR( cl_command_buffer_khr command_buffer, cl_command_queue command_queue, cl_mem src_buffer, cl_mem dst_image, size_t src_offset, const size_t* dst_origin, const size_t* region, cl_uint num_sync_points_in_wait_list, const cl_sync_point_khr* sync_point_wait_list, cl_sync_point_khr* sync_point, cl_mutable_command_khr* mutable_handle) ; extern CL_API_ENTRY cl_int CL_API_CALL clCommandCopyImageKHR( cl_command_buffer_khr command_buffer, cl_command_queue command_queue, cl_mem src_image, cl_mem dst_image, const size_t* src_origin, const size_t* dst_origin, const size_t* region, cl_uint num_sync_points_in_wait_list, const cl_sync_point_khr* sync_point_wait_list, cl_sync_point_khr* sync_point, cl_mutable_command_khr* mutable_handle) ; extern CL_API_ENTRY cl_int CL_API_CALL clCommandCopyImageToBufferKHR( cl_command_buffer_khr command_buffer, cl_command_queue command_queue, cl_mem src_image, cl_mem dst_buffer, const size_t* src_origin, const size_t* region, size_t dst_offset, cl_uint num_sync_points_in_wait_list, const cl_sync_point_khr* sync_point_wait_list, cl_sync_point_khr* sync_point, cl_mutable_command_khr* mutable_handle) ; extern CL_API_ENTRY cl_int CL_API_CALL clCommandFillBufferKHR( cl_command_buffer_khr command_buffer, cl_command_queue command_queue, cl_mem buffer, const void* pattern, size_t pattern_size, size_t offset, size_t size, cl_uint num_sync_points_in_wait_list, const cl_sync_point_khr* sync_point_wait_list, cl_sync_point_khr* sync_point, cl_mutable_command_khr* mutable_handle) ; extern CL_API_ENTRY cl_int CL_API_CALL clCommandFillImageKHR( cl_command_buffer_khr command_buffer, cl_command_queue command_queue, cl_mem image, const void* fill_color, const size_t* origin, const size_t* region, cl_uint num_sync_points_in_wait_list, const cl_sync_point_khr* sync_point_wait_list, cl_sync_point_khr* sync_point, cl_mutable_command_khr* mutable_handle) ; extern CL_API_ENTRY cl_int CL_API_CALL clCommandNDRangeKernelKHR( cl_command_buffer_khr command_buffer, cl_command_queue command_queue, const cl_ndrange_kernel_command_properties_khr* properties, 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_sync_points_in_wait_list, const cl_sync_point_khr* sync_point_wait_list, cl_sync_point_khr* sync_point, cl_mutable_command_khr* mutable_handle) ; extern CL_API_ENTRY cl_int CL_API_CALL clGetCommandBufferInfoKHR( cl_command_buffer_khr command_buffer, cl_command_buffer_info_khr param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret) ; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_khr_command_buffer_multi_device ***************************************************************/ #define cl_khr_command_buffer_multi_device 1 #define CL_KHR_COMMAND_BUFFER_MULTI_DEVICE_EXTENSION_NAME \ "cl_khr_command_buffer_multi_device" typedef cl_bitfield cl_platform_command_buffer_capabilities_khr; /* cl_platform_info */ #define CL_PLATFORM_COMMAND_BUFFER_CAPABILITIES_KHR 0x0908 /* cl_platform_command_buffer_capabilities_khr - bitfield */ #define CL_COMMAND_BUFFER_PLATFORM_UNIVERSAL_SYNC_KHR (1 << 0) #define CL_COMMAND_BUFFER_PLATFORM_REMAP_QUEUES_KHR (1 << 1) #define CL_COMMAND_BUFFER_PLATFORM_AUTOMATIC_REMAP_KHR (1 << 2) /* cl_device_info */ #define CL_DEVICE_COMMAND_BUFFER_NUM_SYNC_DEVICES_KHR 0x12AB #define CL_DEVICE_COMMAND_BUFFER_SYNC_DEVICES_KHR 0x12AC /* cl_device_command_buffer_capabilities_khr - bitfield */ #define CL_COMMAND_BUFFER_CAPABILITY_MULTIPLE_QUEUE_KHR (1 << 4) /* cl_command_buffer_flags_khr - bitfield */ #define CL_COMMAND_BUFFER_DEVICE_SIDE_SYNC_KHR (1 << 2) typedef cl_command_buffer_khr (CL_API_CALL * clRemapCommandBufferKHR_fn)( cl_command_buffer_khr command_buffer, cl_bool automatic, cl_uint num_queues, const cl_command_queue* queues, cl_uint num_handles, const cl_mutable_command_khr* handles, cl_mutable_command_khr* handles_ret, cl_int* errcode_ret) ; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_command_buffer_khr CL_API_CALL clRemapCommandBufferKHR( cl_command_buffer_khr command_buffer, cl_bool automatic, cl_uint num_queues, const cl_command_queue* queues, cl_uint num_handles, const cl_mutable_command_khr* handles, cl_mutable_command_khr* handles_ret, cl_int* errcode_ret) ; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_khr_command_buffer_mutable_dispatch ***************************************************************/ #define cl_khr_command_buffer_mutable_dispatch 1 #define CL_KHR_COMMAND_BUFFER_MUTABLE_DISPATCH_EXTENSION_NAME \ "cl_khr_command_buffer_mutable_dispatch" typedef cl_uint cl_command_buffer_structure_type_khr; typedef cl_bitfield cl_mutable_dispatch_fields_khr; typedef cl_uint cl_mutable_command_info_khr; typedef struct _cl_mutable_dispatch_arg_khr { cl_uint arg_index; size_t arg_size; const void* arg_value; } cl_mutable_dispatch_arg_khr; typedef struct _cl_mutable_dispatch_exec_info_khr { cl_uint param_name; size_t param_value_size; const void* param_value; } cl_mutable_dispatch_exec_info_khr; typedef struct _cl_mutable_dispatch_config_khr { cl_command_buffer_structure_type_khr type; const void* next; cl_mutable_command_khr command; cl_uint num_args; cl_uint num_svm_args; cl_uint num_exec_infos; cl_uint work_dim; const cl_mutable_dispatch_arg_khr* arg_list; const cl_mutable_dispatch_arg_khr* arg_svm_list; const cl_mutable_dispatch_exec_info_khr* exec_info_list; const size_t* global_work_offset; const size_t* global_work_size; const size_t* local_work_size; } cl_mutable_dispatch_config_khr; typedef struct _cl_mutable_base_config_khr { cl_command_buffer_structure_type_khr type; const void* next; cl_uint num_mutable_dispatch; const cl_mutable_dispatch_config_khr* mutable_dispatch_list; } cl_mutable_base_config_khr; /* cl_command_buffer_flags_khr - bitfield */ #define CL_COMMAND_BUFFER_MUTABLE_KHR (1 << 1) /* Error codes */ #define CL_INVALID_MUTABLE_COMMAND_KHR -1141 /* cl_device_info */ #define CL_DEVICE_MUTABLE_DISPATCH_CAPABILITIES_KHR 0x12B0 /* cl_ndrange_kernel_command_properties_khr */ #define CL_MUTABLE_DISPATCH_UPDATABLE_FIELDS_KHR 0x12B1 /* cl_mutable_dispatch_fields_khr - bitfield */ #define CL_MUTABLE_DISPATCH_GLOBAL_OFFSET_KHR (1 << 0) #define CL_MUTABLE_DISPATCH_GLOBAL_SIZE_KHR (1 << 1) #define CL_MUTABLE_DISPATCH_LOCAL_SIZE_KHR (1 << 2) #define CL_MUTABLE_DISPATCH_ARGUMENTS_KHR (1 << 3) #define CL_MUTABLE_DISPATCH_EXEC_INFO_KHR (1 << 4) /* cl_mutable_command_info_khr */ #define CL_MUTABLE_COMMAND_COMMAND_QUEUE_KHR 0x12A0 #define CL_MUTABLE_COMMAND_COMMAND_BUFFER_KHR 0x12A1 #define CL_MUTABLE_COMMAND_COMMAND_TYPE_KHR 0x12AD #define CL_MUTABLE_DISPATCH_PROPERTIES_ARRAY_KHR 0x12A2 #define CL_MUTABLE_DISPATCH_KERNEL_KHR 0x12A3 #define CL_MUTABLE_DISPATCH_DIMENSIONS_KHR 0x12A4 #define CL_MUTABLE_DISPATCH_GLOBAL_WORK_OFFSET_KHR 0x12A5 #define CL_MUTABLE_DISPATCH_GLOBAL_WORK_SIZE_KHR 0x12A6 #define CL_MUTABLE_DISPATCH_LOCAL_WORK_SIZE_KHR 0x12A7 /* cl_command_buffer_structure_type_khr */ #define CL_STRUCTURE_TYPE_MUTABLE_BASE_CONFIG_KHR 0 #define CL_STRUCTURE_TYPE_MUTABLE_DISPATCH_CONFIG_KHR 1 typedef cl_int (CL_API_CALL * clUpdateMutableCommandsKHR_fn)( cl_command_buffer_khr command_buffer, const cl_mutable_base_config_khr* mutable_config) ; typedef cl_int (CL_API_CALL * clGetMutableCommandInfoKHR_fn)( cl_mutable_command_khr command, cl_mutable_command_info_khr param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret) ; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL clUpdateMutableCommandsKHR( cl_command_buffer_khr command_buffer, const cl_mutable_base_config_khr* mutable_config) ; extern CL_API_ENTRY cl_int CL_API_CALL clGetMutableCommandInfoKHR( cl_mutable_command_khr command, cl_mutable_command_info_khr param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret) ; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_khr_fp64 ***************************************************************/ #define cl_khr_fp64 1 #define CL_KHR_FP64_EXTENSION_NAME \ "cl_khr_fp64" #if !defined(CL_VERSION_1_2) /* cl_device_info - defined in CL.h for OpenCL 1.2 and newer */ #define CL_DEVICE_DOUBLE_FP_CONFIG 0x1032 #endif /* !defined(CL_VERSION_1_2) */ /*************************************************************** * cl_khr_fp16 ***************************************************************/ #define cl_khr_fp16 1 #define CL_KHR_FP16_EXTENSION_NAME \ "cl_khr_fp16" /* cl_device_info */ #define CL_DEVICE_HALF_FP_CONFIG 0x1033 /*************************************************************** * cl_APPLE_SetMemObjectDestructor ***************************************************************/ #define cl_APPLE_SetMemObjectDestructor 1 #define CL_APPLE_SETMEMOBJECTDESTRUCTOR_EXTENSION_NAME \ "cl_APPLE_SetMemObjectDestructor" typedef cl_int (CL_API_CALL * clSetMemObjectDestructorAPPLE_fn)( cl_mem memobj, void (CL_CALLBACK* pfn_notify)(cl_mem memobj, void* user_data), void* user_data) CL_API_SUFFIX__VERSION_1_0; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL clSetMemObjectDestructorAPPLE( cl_mem memobj, void (CL_CALLBACK* pfn_notify)(cl_mem memobj, void* user_data), void* user_data) CL_API_SUFFIX__VERSION_1_0; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_APPLE_ContextLoggingFunctions ***************************************************************/ #define cl_APPLE_ContextLoggingFunctions 1 #define CL_APPLE_CONTEXTLOGGINGFUNCTIONS_EXTENSION_NAME \ "cl_APPLE_ContextLoggingFunctions" typedef void (CL_API_CALL * clLogMessagesToSystemLogAPPLE_fn)( const char* errstr, const void* private_info, size_t cb, void* user_data) CL_API_SUFFIX__VERSION_1_0; typedef void (CL_API_CALL * clLogMessagesToStdoutAPPLE_fn)( const char* errstr, const void* private_info, size_t cb, void* user_data) CL_API_SUFFIX__VERSION_1_0; typedef void (CL_API_CALL * clLogMessagesToStderrAPPLE_fn)( const char* errstr, const void* private_info, size_t cb, void* user_data) CL_API_SUFFIX__VERSION_1_0; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY void CL_API_CALL clLogMessagesToSystemLogAPPLE( const char* errstr, const void* private_info, size_t cb, void* user_data) CL_API_SUFFIX__VERSION_1_0; extern CL_API_ENTRY void CL_API_CALL clLogMessagesToStdoutAPPLE( const char* errstr, const void* private_info, size_t cb, void* user_data) CL_API_SUFFIX__VERSION_1_0; extern CL_API_ENTRY void CL_API_CALL clLogMessagesToStderrAPPLE( const char* errstr, const void* private_info, size_t cb, void* user_data) CL_API_SUFFIX__VERSION_1_0; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_khr_icd ***************************************************************/ #define cl_khr_icd 1 #define CL_KHR_ICD_EXTENSION_NAME \ "cl_khr_icd" /* cl_platform_info */ #define CL_PLATFORM_ICD_SUFFIX_KHR 0x0920 /* Error codes */ #define CL_PLATFORM_NOT_FOUND_KHR -1001 typedef cl_int (CL_API_CALL * clIcdGetPlatformIDsKHR_fn)( cl_uint num_entries, cl_platform_id* platforms, cl_uint* num_platforms) ; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL clIcdGetPlatformIDsKHR( cl_uint num_entries, cl_platform_id* platforms, cl_uint* num_platforms) ; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_khr_il_program ***************************************************************/ #define cl_khr_il_program 1 #define CL_KHR_IL_PROGRAM_EXTENSION_NAME \ "cl_khr_il_program" /* cl_device_info */ #define CL_DEVICE_IL_VERSION_KHR 0x105B /* cl_program_info */ #define CL_PROGRAM_IL_KHR 0x1169 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; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithILKHR( cl_context context, const void* il, size_t length, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_khr_image2d_from_buffer ***************************************************************/ #define cl_khr_image2d_from_buffer 1 #define CL_KHR_IMAGE2D_FROM_BUFFER_EXTENSION_NAME \ "cl_khr_image2d_from_buffer" /* cl_device_info */ #define CL_DEVICE_IMAGE_PITCH_ALIGNMENT_KHR 0x104A #define CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT_KHR 0x104B /*************************************************************** * cl_khr_initialize_memory ***************************************************************/ #define cl_khr_initialize_memory 1 #define CL_KHR_INITIALIZE_MEMORY_EXTENSION_NAME \ "cl_khr_initialize_memory" /* Interop tokens */ #define CL_CONTEXT_MEMORY_INITIALIZE_KHR 0x2030 /*************************************************************** * cl_khr_terminate_context ***************************************************************/ #define cl_khr_terminate_context 1 #define CL_KHR_TERMINATE_CONTEXT_EXTENSION_NAME \ "cl_khr_terminate_context" typedef cl_bitfield cl_device_terminate_capability_khr; /* cl_device_info */ #define CL_DEVICE_TERMINATE_CAPABILITY_KHR 0x2031 /* cl_context_properties */ #define CL_CONTEXT_TERMINATE_KHR 0x2032 /* cl_device_terminate_capability_khr */ #define CL_DEVICE_TERMINATE_CAPABILITY_CONTEXT_KHR (1 << 0) /* Error codes */ #define CL_CONTEXT_TERMINATED_KHR -1121 typedef cl_int (CL_API_CALL * clTerminateContextKHR_fn)( cl_context context) CL_API_SUFFIX__VERSION_1_2; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL clTerminateContextKHR( cl_context context) CL_API_SUFFIX__VERSION_1_2; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_khr_spir ***************************************************************/ #define cl_khr_spir 1 #define CL_KHR_SPIR_EXTENSION_NAME \ "cl_khr_spir" /* cl_device_info */ #define CL_DEVICE_SPIR_VERSIONS 0x40E0 /* cl_program_binary_type */ #define CL_PROGRAM_BINARY_TYPE_INTERMEDIATE 0x40E1 /*************************************************************** * cl_khr_create_command_queue ***************************************************************/ #define cl_khr_create_command_queue 1 #define CL_KHR_CREATE_COMMAND_QUEUE_EXTENSION_NAME \ "cl_khr_create_command_queue" typedef cl_properties cl_queue_properties_khr; typedef cl_command_queue (CL_API_CALL * clCreateCommandQueueWithPropertiesKHR_fn)( cl_context context, cl_device_id device, const cl_queue_properties_khr* properties, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_command_queue CL_API_CALL clCreateCommandQueueWithPropertiesKHR( cl_context context, cl_device_id device, const cl_queue_properties_khr* properties, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_nv_device_attribute_query ***************************************************************/ #define cl_nv_device_attribute_query 1 #define CL_NV_DEVICE_ATTRIBUTE_QUERY_EXTENSION_NAME \ "cl_nv_device_attribute_query" /* cl_device_info */ #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_attribute_query ***************************************************************/ #define cl_amd_device_attribute_query 1 #define CL_AMD_DEVICE_ATTRIBUTE_QUERY_EXTENSION_NAME \ "cl_amd_device_attribute_query" /* cl_device_info */ #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 /*************************************************************** * cl_arm_printf ***************************************************************/ #define cl_arm_printf 1 #define CL_ARM_PRINTF_EXTENSION_NAME \ "cl_arm_printf" /* cl_context_properties */ #define CL_PRINTF_CALLBACK_ARM 0x40B0 #define CL_PRINTF_BUFFERSIZE_ARM 0x40B1 /*************************************************************** * cl_ext_device_fission ***************************************************************/ #define cl_ext_device_fission 1 #define CL_EXT_DEVICE_FISSION_EXTENSION_NAME \ "cl_ext_device_fission" typedef cl_ulong cl_device_partition_property_ext; /* Error codes */ #define CL_DEVICE_PARTITION_FAILED_EXT -1057 #define CL_INVALID_PARTITION_COUNT_EXT -1058 #define CL_INVALID_PARTITION_NAME_EXT -1059 /* cl_device_info */ #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 /* 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 /* cl_device_partition_property_ext - 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) typedef cl_int (CL_API_CALL * clReleaseDeviceEXT_fn)( cl_device_id device) CL_API_SUFFIX__VERSION_1_1; typedef cl_int (CL_API_CALL * clRetainDeviceEXT_fn)( cl_device_id device) CL_API_SUFFIX__VERSION_1_1; typedef 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_API_SUFFIX__VERSION_1_1; #if !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL clReleaseDeviceEXT( cl_device_id device) CL_API_SUFFIX__VERSION_1_1; extern CL_API_ENTRY cl_int CL_API_CALL clRetainDeviceEXT( cl_device_id device) CL_API_SUFFIX__VERSION_1_1; 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_API_SUFFIX__VERSION_1_1; #endif /* !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_ext_migrate_memobject ***************************************************************/ #define cl_ext_migrate_memobject 1 #define CL_EXT_MIGRATE_MEMOBJECT_EXTENSION_NAME \ "cl_ext_migrate_memobject" typedef cl_bitfield cl_mem_migration_flags_ext; /* cl_mem_migration_flags_ext */ #define CL_MIGRATE_MEM_OBJECT_HOST_EXT (1 << 0) /* cl_command_type */ #define CL_COMMAND_MIGRATE_MEM_OBJECT_EXT 0x4040 typedef cl_int (CL_API_CALL * clEnqueueMigrateMemObjectEXT_fn)( cl_command_queue command_queue, cl_uint num_mem_objects, const cl_mem* mem_objects, cl_mem_migration_flags_ext flags, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event) ; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueMigrateMemObjectEXT( cl_command_queue command_queue, cl_uint num_mem_objects, const cl_mem* mem_objects, cl_mem_migration_flags_ext flags, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event) ; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_ext_cxx_for_opencl ***************************************************************/ #define cl_ext_cxx_for_opencl 1 #define CL_EXT_CXX_FOR_OPENCL_EXTENSION_NAME \ "cl_ext_cxx_for_opencl" /* cl_device_info */ #define CL_DEVICE_CXX_FOR_OPENCL_NUMERIC_VERSION_EXT 0x4230 /*************************************************************** * cl_qcom_ext_host_ptr ***************************************************************/ #define cl_qcom_ext_host_ptr 1 #define CL_QCOM_EXT_HOST_PTR_EXTENSION_NAME \ "cl_qcom_ext_host_ptr" typedef cl_uint cl_image_pitch_info_qcom; typedef struct _cl_mem_ext_host_ptr { cl_uint allocation_type; cl_uint host_cache_policy; } cl_mem_ext_host_ptr; /* cl_mem_flags */ #define CL_MEM_EXT_HOST_PTR_QCOM (1 << 29) /* cl_device_info */ #define CL_DEVICE_EXT_MEM_PADDING_IN_BYTES_QCOM 0x40A0 #define CL_DEVICE_PAGE_SIZE_QCOM 0x40A1 /* cl_image_pitch_info_qcom */ #define CL_IMAGE_ROW_ALIGNMENT_QCOM 0x40A2 #define CL_IMAGE_SLICE_ALIGNMENT_QCOM 0x40A3 /* cl_uint host_cache_policy */ #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_int (CL_API_CALL * clGetDeviceImageInfoQCOM_fn)( 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) ; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) 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) ; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_qcom_ext_host_ptr_iocoherent ***************************************************************/ #define cl_qcom_ext_host_ptr_iocoherent 1 #define CL_QCOM_EXT_HOST_PTR_IOCOHERENT_EXTENSION_NAME \ "cl_qcom_ext_host_ptr_iocoherent" /* cl_uint host_cache_policy */ #define CL_MEM_HOST_IOCOHERENT_QCOM 0x40A9 /*************************************************************** * cl_qcom_ion_host_ptr ***************************************************************/ #define cl_qcom_ion_host_ptr 1 #define CL_QCOM_ION_HOST_PTR_EXTENSION_NAME \ "cl_qcom_ion_host_ptr" /* type cl_mem_ext_host_ptr */ typedef struct _cl_mem_ion_host_ptr { cl_mem_ext_host_ptr ext_host_ptr; int ion_filedesc; void* ion_hostptr; } cl_mem_ion_host_ptr; /* cl_uint allocation_type */ #define CL_MEM_ION_HOST_PTR_QCOM 0x40A8 /*************************************************************** * cl_qcom_android_native_buffer_host_ptr ***************************************************************/ #define cl_qcom_android_native_buffer_host_ptr 1 #define CL_QCOM_ANDROID_NATIVE_BUFFER_HOST_PTR_EXTENSION_NAME \ "cl_qcom_android_native_buffer_host_ptr" /* type cl_mem_ext_host_ptr */ typedef struct _cl_mem_android_native_buffer_host_ptr { cl_mem_ext_host_ptr ext_host_ptr; void* anb_ptr; } cl_mem_android_native_buffer_host_ptr; /* cl_uint allocation_type */ #define CL_MEM_ANDROID_NATIVE_BUFFER_HOST_PTR_QCOM 0x40C6 /*************************************************************** * cl_img_yuv_image ***************************************************************/ #define cl_img_yuv_image 1 #define CL_IMG_YUV_IMAGE_EXTENSION_NAME \ "cl_img_yuv_image" /* cl_channel_order */ #define CL_NV21_IMG 0x40D0 #define CL_YV12_IMG 0x40D1 /*************************************************************** * cl_img_cached_allocations ***************************************************************/ #define cl_img_cached_allocations 1 #define CL_IMG_CACHED_ALLOCATIONS_EXTENSION_NAME \ "cl_img_cached_allocations" /* cl_mem_flags */ #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 ***************************************************************/ #define cl_img_use_gralloc_ptr 1 #define CL_IMG_USE_GRALLOC_PTR_EXTENSION_NAME \ "cl_img_use_gralloc_ptr" /* Error codes */ #define CL_GRALLOC_RESOURCE_NOT_ACQUIRED_IMG 0x40D4 #define CL_INVALID_GRALLOC_OBJECT_IMG 0x40D5 /* cl_mem_flags */ #define CL_MEM_USE_GRALLOC_PTR_IMG (1 << 28) /* cl_command_type */ #define CL_COMMAND_ACQUIRE_GRALLOC_OBJECTS_IMG 0x40D2 #define CL_COMMAND_RELEASE_GRALLOC_OBJECTS_IMG 0x40D3 typedef cl_int (CL_API_CALL * clEnqueueAcquireGrallocObjectsIMG_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_2; typedef cl_int (CL_API_CALL * clEnqueueReleaseGrallocObjectsIMG_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_2; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) 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_API_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_API_SUFFIX__VERSION_1_2; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_img_generate_mipmap ***************************************************************/ #define cl_img_generate_mipmap 1 #define CL_IMG_GENERATE_MIPMAP_EXTENSION_NAME \ "cl_img_generate_mipmap" typedef cl_uint cl_mipmap_filter_mode_img; /* cl_mipmap_filter_mode_img */ #define CL_MIPMAP_FILTER_ANY_IMG 0x0 #define CL_MIPMAP_FILTER_BOX_IMG 0x1 /* cl_command_type */ #define CL_COMMAND_GENERATE_MIPMAP_IMG 0x40D6 typedef cl_int (CL_API_CALL * clEnqueueGenerateMipmapIMG_fn)( cl_command_queue command_queue, cl_mem src_image, cl_mem dst_image, cl_mipmap_filter_mode_img mipmap_filter_mode, const size_t* array_region, const size_t* mip_region, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event) CL_API_SUFFIX__VERSION_1_2; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueGenerateMipmapIMG( cl_command_queue command_queue, cl_mem src_image, cl_mem dst_image, cl_mipmap_filter_mode_img mipmap_filter_mode, const size_t* array_region, const size_t* mip_region, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event) CL_API_SUFFIX__VERSION_1_2; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_img_mem_properties ***************************************************************/ #define cl_img_mem_properties 1 #define CL_IMG_MEM_PROPERTIES_EXTENSION_NAME \ "cl_img_mem_properties" /* cl_mem_properties */ #define CL_MEM_ALLOC_FLAGS_IMG 0x40D7 /* cl_mem_alloc_flags_img */ #define CL_MEM_ALLOC_RELAX_REQUIREMENTS_IMG (1 << 0) /*************************************************************** * cl_khr_subgroups ***************************************************************/ #define cl_khr_subgroups 1 #define CL_KHR_SUBGROUPS_EXTENSION_NAME \ "cl_khr_subgroups" #if !defined(CL_VERSION_2_1) /* defined in CL.h for OpenCL 2.1 and newer */ typedef cl_uint cl_kernel_sub_group_info; #endif /* !defined(CL_VERSION_2_1) */ /* 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 typedef 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_API_SUFFIX__VERSION_2_0_DEPRECATED; #if !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) 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_API_SUFFIX__VERSION_2_0_DEPRECATED; #endif /* !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_khr_mipmap_image ***************************************************************/ #define cl_khr_mipmap_image 1 #define CL_KHR_MIPMAP_IMAGE_EXTENSION_NAME \ "cl_khr_mipmap_image" /* cl_sampler_properties */ #define CL_SAMPLER_MIP_FILTER_MODE_KHR 0x1155 #define CL_SAMPLER_LOD_MIN_KHR 0x1156 #define CL_SAMPLER_LOD_MAX_KHR 0x1157 /*************************************************************** * cl_khr_priority_hints ***************************************************************/ #define cl_khr_priority_hints 1 #define CL_KHR_PRIORITY_HINTS_EXTENSION_NAME \ "cl_khr_priority_hints" /* To be used by clGetEventInfo */ typedef cl_uint cl_queue_priority_khr; /* cl_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) /*************************************************************** * cl_khr_throttle_hints ***************************************************************/ #define cl_khr_throttle_hints 1 #define CL_KHR_THROTTLE_HINTS_EXTENSION_NAME \ "cl_khr_throttle_hints" /* To be used by clGetEventInfo */ typedef cl_uint cl_queue_throttle_khr; /* cl_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) /*************************************************************** * cl_khr_subgroup_named_barrier ***************************************************************/ #define cl_khr_subgroup_named_barrier 1 #define CL_KHR_SUBGROUP_NAMED_BARRIER_EXTENSION_NAME \ "cl_khr_subgroup_named_barrier" /* cl_device_info */ #define CL_DEVICE_MAX_NAMED_BARRIER_COUNT_KHR 0x2035 /*************************************************************** * cl_khr_extended_versioning ***************************************************************/ #define cl_khr_extended_versioning 1 #define CL_KHR_EXTENDED_VERSIONING_EXTENSION_NAME \ "cl_khr_extended_versioning" #define CL_VERSION_MAJOR_BITS_KHR 10 #define CL_VERSION_MINOR_BITS_KHR 10 #define CL_VERSION_PATCH_BITS_KHR 12 #define CL_VERSION_MAJOR_MASK_KHR ((1 << CL_VERSION_MAJOR_BITS_KHR) - 1) #define CL_VERSION_MINOR_MASK_KHR ((1 << CL_VERSION_MINOR_BITS_KHR) - 1) #define CL_VERSION_PATCH_MASK_KHR ((1 << CL_VERSION_PATCH_BITS_KHR) - 1) #define CL_VERSION_MAJOR_KHR(version) ((version) >> (CL_VERSION_MINOR_BITS_KHR + CL_VERSION_PATCH_BITS_KHR)) #define CL_VERSION_MINOR_KHR(version) (((version) >> CL_VERSION_PATCH_BITS_KHR) & CL_VERSION_MINOR_MASK_KHR) #define CL_VERSION_PATCH_KHR(version) ((version) & CL_VERSION_PATCH_MASK_KHR) #define CL_MAKE_VERSION_KHR(major, minor, patch) \ ((((major) & CL_VERSION_MAJOR_MASK_KHR) << (CL_VERSION_MINOR_BITS_KHR + CL_VERSION_PATCH_BITS_KHR)) | \ (((minor) & CL_VERSION_MINOR_MASK_KHR) << CL_VERSION_PATCH_BITS_KHR) | \ ((patch) & CL_VERSION_PATCH_MASK_KHR)) #define CL_NAME_VERSION_MAX_NAME_SIZE_KHR 64 typedef cl_uint cl_version_khr; typedef struct _cl_name_version_khr { cl_version_khr version; char name[CL_NAME_VERSION_MAX_NAME_SIZE_KHR]; } cl_name_version_khr; /* cl_platform_info */ #define CL_PLATFORM_NUMERIC_VERSION_KHR 0x0906 #define CL_PLATFORM_EXTENSIONS_WITH_VERSION_KHR 0x0907 /* cl_device_info */ #define CL_DEVICE_NUMERIC_VERSION_KHR 0x105E #define CL_DEVICE_OPENCL_C_NUMERIC_VERSION_KHR 0x105F #define CL_DEVICE_EXTENSIONS_WITH_VERSION_KHR 0x1060 #define CL_DEVICE_ILS_WITH_VERSION_KHR 0x1061 #define CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION_KHR 0x1062 /*************************************************************** * cl_khr_device_uuid ***************************************************************/ #define cl_khr_device_uuid 1 #define CL_KHR_DEVICE_UUID_EXTENSION_NAME \ "cl_khr_device_uuid" /* Size Constants */ #define CL_UUID_SIZE_KHR 16 #define CL_LUID_SIZE_KHR 8 /* cl_device_info */ #define CL_DEVICE_UUID_KHR 0x106A #define CL_DRIVER_UUID_KHR 0x106B #define CL_DEVICE_LUID_VALID_KHR 0x106C #define CL_DEVICE_LUID_KHR 0x106D #define CL_DEVICE_NODE_MASK_KHR 0x106E /*************************************************************** * cl_khr_pci_bus_info ***************************************************************/ #define cl_khr_pci_bus_info 1 #define CL_KHR_PCI_BUS_INFO_EXTENSION_NAME \ "cl_khr_pci_bus_info" typedef struct _cl_device_pci_bus_info_khr { cl_uint pci_domain; cl_uint pci_bus; cl_uint pci_device; cl_uint pci_function; } cl_device_pci_bus_info_khr; /* cl_device_info */ #define CL_DEVICE_PCI_BUS_INFO_KHR 0x410F /*************************************************************** * cl_khr_suggested_local_work_size ***************************************************************/ #define cl_khr_suggested_local_work_size 1 #define CL_KHR_SUGGESTED_LOCAL_WORK_SIZE_EXTENSION_NAME \ "cl_khr_suggested_local_work_size" typedef cl_int (CL_API_CALL * clGetKernelSuggestedLocalWorkSizeKHR_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, size_t* suggested_local_work_size) CL_API_SUFFIX__VERSION_3_0; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL clGetKernelSuggestedLocalWorkSizeKHR( cl_command_queue command_queue, cl_kernel kernel, cl_uint work_dim, const size_t* global_work_offset, const size_t* global_work_size, size_t* suggested_local_work_size) CL_API_SUFFIX__VERSION_3_0; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_khr_integer_dot_product ***************************************************************/ #define cl_khr_integer_dot_product 1 #define CL_KHR_INTEGER_DOT_PRODUCT_EXTENSION_NAME \ "cl_khr_integer_dot_product" typedef cl_bitfield cl_device_integer_dot_product_capabilities_khr; typedef struct _cl_device_integer_dot_product_acceleration_properties_khr { cl_bool signed_accelerated; cl_bool unsigned_accelerated; cl_bool mixed_signedness_accelerated; cl_bool accumulating_saturating_signed_accelerated; cl_bool accumulating_saturating_unsigned_accelerated; cl_bool accumulating_saturating_mixed_signedness_accelerated; } cl_device_integer_dot_product_acceleration_properties_khr; /* cl_device_integer_dot_product_capabilities_khr */ #define CL_DEVICE_INTEGER_DOT_PRODUCT_INPUT_4x8BIT_PACKED_KHR (1 << 0) #define CL_DEVICE_INTEGER_DOT_PRODUCT_INPUT_4x8BIT_KHR (1 << 1) /* cl_device_info */ #define CL_DEVICE_INTEGER_DOT_PRODUCT_CAPABILITIES_KHR 0x1073 #define CL_DEVICE_INTEGER_DOT_PRODUCT_ACCELERATION_PROPERTIES_8BIT_KHR 0x1074 #define CL_DEVICE_INTEGER_DOT_PRODUCT_ACCELERATION_PROPERTIES_4x8BIT_PACKED_KHR 0x1075 /*************************************************************** * cl_khr_external_memory ***************************************************************/ #define cl_khr_external_memory 1 #define CL_KHR_EXTERNAL_MEMORY_EXTENSION_NAME \ "cl_khr_external_memory" typedef cl_uint cl_external_memory_handle_type_khr; /* cl_platform_info */ #define CL_PLATFORM_EXTERNAL_MEMORY_IMPORT_HANDLE_TYPES_KHR 0x2044 /* cl_device_info */ #define CL_DEVICE_EXTERNAL_MEMORY_IMPORT_HANDLE_TYPES_KHR 0x204F /* cl_mem_properties */ #define CL_DEVICE_HANDLE_LIST_KHR 0x2051 #define CL_DEVICE_HANDLE_LIST_END_KHR 0 /* cl_command_type */ #define CL_COMMAND_ACQUIRE_EXTERNAL_MEM_OBJECTS_KHR 0x2047 #define CL_COMMAND_RELEASE_EXTERNAL_MEM_OBJECTS_KHR 0x2048 typedef cl_int (CL_API_CALL * clEnqueueAcquireExternalMemObjectsKHR_fn)( cl_command_queue command_queue, cl_uint num_mem_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_3_0; typedef cl_int (CL_API_CALL * clEnqueueReleaseExternalMemObjectsKHR_fn)( cl_command_queue command_queue, cl_uint num_mem_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_3_0; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireExternalMemObjectsKHR( cl_command_queue command_queue, cl_uint num_mem_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_3_0; extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseExternalMemObjectsKHR( cl_command_queue command_queue, cl_uint num_mem_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_3_0; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_khr_external_memory_dma_buf ***************************************************************/ #define cl_khr_external_memory_dma_buf 1 #define CL_KHR_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME \ "cl_khr_external_memory_dma_buf" /* cl_external_memory_handle_type_khr */ #define CL_EXTERNAL_MEMORY_HANDLE_DMA_BUF_KHR 0x2067 /*************************************************************** * cl_khr_external_memory_dx ***************************************************************/ #define cl_khr_external_memory_dx 1 #define CL_KHR_EXTERNAL_MEMORY_DX_EXTENSION_NAME \ "cl_khr_external_memory_dx" /* cl_external_memory_handle_type_khr */ #define CL_EXTERNAL_MEMORY_HANDLE_D3D11_TEXTURE_KHR 0x2063 #define CL_EXTERNAL_MEMORY_HANDLE_D3D11_TEXTURE_KMT_KHR 0x2064 #define CL_EXTERNAL_MEMORY_HANDLE_D3D12_HEAP_KHR 0x2065 #define CL_EXTERNAL_MEMORY_HANDLE_D3D12_RESOURCE_KHR 0x2066 /*************************************************************** * cl_khr_external_memory_opaque_fd ***************************************************************/ #define cl_khr_external_memory_opaque_fd 1 #define CL_KHR_EXTERNAL_MEMORY_OPAQUE_FD_EXTENSION_NAME \ "cl_khr_external_memory_opaque_fd" /* cl_external_memory_handle_type_khr */ #define CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_FD_KHR 0x2060 /*************************************************************** * cl_khr_external_memory_win32 ***************************************************************/ #define cl_khr_external_memory_win32 1 #define CL_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME \ "cl_khr_external_memory_win32" /* cl_external_memory_handle_type_khr */ #define CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KHR 0x2061 #define CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KMT_KHR 0x2062 /*************************************************************** * cl_khr_external_semaphore ***************************************************************/ #define cl_khr_external_semaphore 1 #define CL_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME \ "cl_khr_external_semaphore" typedef struct _cl_semaphore_khr * cl_semaphore_khr; typedef cl_uint cl_external_semaphore_handle_type_khr; /* cl_platform_info */ #define CL_PLATFORM_SEMAPHORE_IMPORT_HANDLE_TYPES_KHR 0x2037 #define CL_PLATFORM_SEMAPHORE_EXPORT_HANDLE_TYPES_KHR 0x2038 /* cl_device_info */ #define CL_DEVICE_SEMAPHORE_IMPORT_HANDLE_TYPES_KHR 0x204D #define CL_DEVICE_SEMAPHORE_EXPORT_HANDLE_TYPES_KHR 0x204E /* cl_semaphore_properties_khr */ #define CL_SEMAPHORE_EXPORT_HANDLE_TYPES_KHR 0x203F #define CL_SEMAPHORE_EXPORT_HANDLE_TYPES_LIST_END_KHR 0 typedef cl_int (CL_API_CALL * clGetSemaphoreHandleForTypeKHR_fn)( cl_semaphore_khr sema_object, cl_device_id device, cl_external_semaphore_handle_type_khr handle_type, size_t handle_size, void* handle_ptr, size_t* handle_size_ret) CL_API_SUFFIX__VERSION_1_2; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL clGetSemaphoreHandleForTypeKHR( cl_semaphore_khr sema_object, cl_device_id device, cl_external_semaphore_handle_type_khr handle_type, size_t handle_size, void* handle_ptr, size_t* handle_size_ret) CL_API_SUFFIX__VERSION_1_2; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_khr_external_semaphore_dx_fence ***************************************************************/ #define cl_khr_external_semaphore_dx_fence 1 #define CL_KHR_EXTERNAL_SEMAPHORE_DX_FENCE_EXTENSION_NAME \ "cl_khr_external_semaphore_dx_fence" /* cl_external_semaphore_handle_type_khr */ #define CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR 0x2059 /*************************************************************** * cl_khr_external_semaphore_opaque_fd ***************************************************************/ #define cl_khr_external_semaphore_opaque_fd 1 #define CL_KHR_EXTERNAL_SEMAPHORE_OPAQUE_FD_EXTENSION_NAME \ "cl_khr_external_semaphore_opaque_fd" /* cl_external_semaphore_handle_type_khr */ #define CL_SEMAPHORE_HANDLE_OPAQUE_FD_KHR 0x2055 /*************************************************************** * cl_khr_external_semaphore_sync_fd ***************************************************************/ #define cl_khr_external_semaphore_sync_fd 1 #define CL_KHR_EXTERNAL_SEMAPHORE_SYNC_FD_EXTENSION_NAME \ "cl_khr_external_semaphore_sync_fd" /* cl_external_semaphore_handle_type_khr */ #define CL_SEMAPHORE_HANDLE_SYNC_FD_KHR 0x2058 /*************************************************************** * cl_khr_external_semaphore_win32 ***************************************************************/ #define cl_khr_external_semaphore_win32 1 #define CL_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME \ "cl_khr_external_semaphore_win32" /* cl_external_semaphore_handle_type_khr */ #define CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KHR 0x2056 #define CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KMT_KHR 0x2057 /*************************************************************** * cl_khr_semaphore ***************************************************************/ #define cl_khr_semaphore 1 #define CL_KHR_SEMAPHORE_EXTENSION_NAME \ "cl_khr_semaphore" /* type cl_semaphore_khr */ typedef cl_properties cl_semaphore_properties_khr; typedef cl_uint cl_semaphore_info_khr; typedef cl_uint cl_semaphore_type_khr; typedef cl_ulong cl_semaphore_payload_khr; /* cl_semaphore_type */ #define CL_SEMAPHORE_TYPE_BINARY_KHR 1 /* cl_platform_info */ #define CL_PLATFORM_SEMAPHORE_TYPES_KHR 0x2036 /* cl_device_info */ #define CL_DEVICE_SEMAPHORE_TYPES_KHR 0x204C /* cl_semaphore_info_khr */ #define CL_SEMAPHORE_CONTEXT_KHR 0x2039 #define CL_SEMAPHORE_REFERENCE_COUNT_KHR 0x203A #define CL_SEMAPHORE_PROPERTIES_KHR 0x203B #define CL_SEMAPHORE_PAYLOAD_KHR 0x203C /* cl_semaphore_info_khr or cl_semaphore_properties_khr */ #define CL_SEMAPHORE_TYPE_KHR 0x203D /* enum CL_DEVICE_HANDLE_LIST_KHR */ /* enum CL_DEVICE_HANDLE_LIST_END_KHR */ /* cl_command_type */ #define CL_COMMAND_SEMAPHORE_WAIT_KHR 0x2042 #define CL_COMMAND_SEMAPHORE_SIGNAL_KHR 0x2043 /* Error codes */ #define CL_INVALID_SEMAPHORE_KHR -1142 typedef cl_semaphore_khr (CL_API_CALL * clCreateSemaphoreWithPropertiesKHR_fn)( cl_context context, const cl_semaphore_properties_khr* sema_props, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; typedef cl_int (CL_API_CALL * clEnqueueWaitSemaphoresKHR_fn)( cl_command_queue command_queue, cl_uint num_sema_objects, const cl_semaphore_khr* sema_objects, const cl_semaphore_payload_khr* sema_payload_list, 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 * clEnqueueSignalSemaphoresKHR_fn)( cl_command_queue command_queue, cl_uint num_sema_objects, const cl_semaphore_khr* sema_objects, const cl_semaphore_payload_khr* sema_payload_list, 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 * clGetSemaphoreInfoKHR_fn)( cl_semaphore_khr sema_object, cl_semaphore_info_khr 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 * clReleaseSemaphoreKHR_fn)( cl_semaphore_khr sema_object) CL_API_SUFFIX__VERSION_1_2; typedef cl_int (CL_API_CALL * clRetainSemaphoreKHR_fn)( cl_semaphore_khr sema_object) CL_API_SUFFIX__VERSION_1_2; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_semaphore_khr CL_API_CALL clCreateSemaphoreWithPropertiesKHR( cl_context context, const cl_semaphore_properties_khr* sema_props, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueWaitSemaphoresKHR( cl_command_queue command_queue, cl_uint num_sema_objects, const cl_semaphore_khr* sema_objects, const cl_semaphore_payload_khr* sema_payload_list, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event) CL_API_SUFFIX__VERSION_1_2; extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueSignalSemaphoresKHR( cl_command_queue command_queue, cl_uint num_sema_objects, const cl_semaphore_khr* sema_objects, const cl_semaphore_payload_khr* sema_payload_list, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event) CL_API_SUFFIX__VERSION_1_2; extern CL_API_ENTRY cl_int CL_API_CALL clGetSemaphoreInfoKHR( cl_semaphore_khr sema_object, cl_semaphore_info_khr param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_2; extern CL_API_ENTRY cl_int CL_API_CALL clReleaseSemaphoreKHR( cl_semaphore_khr sema_object) CL_API_SUFFIX__VERSION_1_2; extern CL_API_ENTRY cl_int CL_API_CALL clRetainSemaphoreKHR( cl_semaphore_khr sema_object) CL_API_SUFFIX__VERSION_1_2; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_arm_import_memory ***************************************************************/ #define cl_arm_import_memory 1 #define CL_ARM_IMPORT_MEMORY_EXTENSION_NAME \ "cl_arm_import_memory" typedef intptr_t cl_import_properties_arm; /* cl_import_properties_arm */ #define CL_IMPORT_TYPE_ARM 0x40B2 #define CL_IMPORT_TYPE_HOST_ARM 0x40B3 #define CL_IMPORT_TYPE_DMA_BUF_ARM 0x40B4 #define CL_IMPORT_TYPE_PROTECTED_ARM 0x40B5 #define CL_IMPORT_TYPE_ANDROID_HARDWARE_BUFFER_ARM 0x41E2 #define CL_IMPORT_DMA_BUF_DATA_CONSISTENCY_WITH_HOST_ARM 0x41E3 #define CL_IMPORT_MEMORY_WHOLE_ALLOCATION_ARM SIZE_MAX #define CL_IMPORT_ANDROID_HARDWARE_BUFFER_PLANE_INDEX_ARM 0x41EF #define CL_IMPORT_ANDROID_HARDWARE_BUFFER_LAYER_INDEX_ARM 0x41F0 typedef cl_mem (CL_API_CALL * clImportMemoryARM_fn)( cl_context context, cl_mem_flags flags, const cl_import_properties_arm* properties, void* memory, size_t size, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) 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_API_SUFFIX__VERSION_1_0; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_arm_shared_virtual_memory ***************************************************************/ #define cl_arm_shared_virtual_memory 1 #define CL_ARM_SHARED_VIRTUAL_MEMORY_EXTENSION_NAME \ "cl_arm_shared_virtual_memory" typedef cl_bitfield cl_svm_mem_flags_arm; typedef cl_uint cl_kernel_exec_info_arm; typedef cl_bitfield cl_device_svm_capabilities_arm; /* cl_device_info */ #define CL_DEVICE_SVM_CAPABILITIES_ARM 0x40B6 /* cl_mem_info */ #define CL_MEM_USES_SVM_POINTER_ARM 0x40B7 /* cl_kernel_exec_info_arm */ #define CL_KERNEL_EXEC_INFO_SVM_PTRS_ARM 0x40B8 #define CL_KERNEL_EXEC_INFO_SVM_FINE_GRAIN_SYSTEM_ARM 0x40B9 /* cl_command_type */ #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 /* cl_device_svm_capabilities_arm */ #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) /* cl_svm_mem_flags_arm */ #define CL_MEM_SVM_FINE_GRAIN_BUFFER_ARM (1 << 10) #define CL_MEM_SVM_ATOMICS_ARM (1 << 11) typedef void* (CL_API_CALL * clSVMAllocARM_fn)( cl_context context, cl_svm_mem_flags_arm flags, size_t size, cl_uint alignment) CL_API_SUFFIX__VERSION_1_2; typedef void (CL_API_CALL * clSVMFreeARM_fn)( cl_context context, void* svm_pointer) CL_API_SUFFIX__VERSION_1_2; typedef cl_int (CL_API_CALL * clEnqueueSVMFreeARM_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_1_2; typedef cl_int (CL_API_CALL * clEnqueueSVMMemcpyARM_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_1_2; typedef cl_int (CL_API_CALL * clEnqueueSVMMemFillARM_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_1_2; typedef cl_int (CL_API_CALL * clEnqueueSVMMapARM_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_1_2; typedef cl_int (CL_API_CALL * clEnqueueSVMUnmapARM_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_1_2; typedef cl_int (CL_API_CALL * clSetKernelArgSVMPointerARM_fn)( cl_kernel kernel, cl_uint arg_index, const void* arg_value) CL_API_SUFFIX__VERSION_1_2; typedef cl_int (CL_API_CALL * clSetKernelExecInfoARM_fn)( cl_kernel kernel, cl_kernel_exec_info_arm param_name, size_t param_value_size, const void* param_value) CL_API_SUFFIX__VERSION_1_2; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) 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_API_SUFFIX__VERSION_1_2; extern CL_API_ENTRY void CL_API_CALL clSVMFreeARM( cl_context context, void* svm_pointer) CL_API_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_API_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_API_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_API_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_API_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_API_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_API_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_API_SUFFIX__VERSION_1_2; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_arm_get_core_id ***************************************************************/ #if defined(CL_VERSION_1_2) #define cl_arm_get_core_id 1 #define CL_ARM_GET_CORE_ID_EXTENSION_NAME \ "cl_arm_get_core_id" /* cl_device_info */ #define CL_DEVICE_COMPUTE_UNITS_BITFIELD_ARM 0x40BF #endif /* defined(CL_VERSION_1_2) */ /*************************************************************** * cl_arm_job_slot_selection ***************************************************************/ #define cl_arm_job_slot_selection 1 #define CL_ARM_JOB_SLOT_SELECTION_EXTENSION_NAME \ "cl_arm_job_slot_selection" /* cl_device_info */ #define CL_DEVICE_JOB_SLOTS_ARM 0x41E0 /* cl_queue_properties */ #define CL_QUEUE_JOB_SLOT_ARM 0x41E1 /*************************************************************** * cl_arm_scheduling_controls ***************************************************************/ #define cl_arm_scheduling_controls 1 #define CL_ARM_SCHEDULING_CONTROLS_EXTENSION_NAME \ "cl_arm_scheduling_controls" /* Types */ typedef cl_bitfield cl_device_scheduling_controls_capabilities_arm; /* cl_device_scheduling_controls_capabilities_arm */ #define CL_DEVICE_SCHEDULING_KERNEL_BATCHING_ARM (1 << 0) #define CL_DEVICE_SCHEDULING_WORKGROUP_BATCH_SIZE_ARM (1 << 1) #define CL_DEVICE_SCHEDULING_WORKGROUP_BATCH_SIZE_MODIFIER_ARM (1 << 2) #define CL_DEVICE_SCHEDULING_DEFERRED_FLUSH_ARM (1 << 3) #define CL_DEVICE_SCHEDULING_REGISTER_ALLOCATION_ARM (1 << 4) #define CL_DEVICE_SCHEDULING_WARP_THROTTLING_ARM (1 << 5) #define CL_DEVICE_SCHEDULING_COMPUTE_UNIT_BATCH_QUEUE_SIZE_ARM (1 << 6) /* cl_device_info */ #define CL_DEVICE_SCHEDULING_CONTROLS_CAPABILITIES_ARM 0x41E4 #define CL_DEVICE_SUPPORTED_REGISTER_ALLOCATIONS_ARM 0x41EB #define CL_DEVICE_MAX_WARP_COUNT_ARM 0x41EA /* cl_kernel_exec_info */ #define CL_KERNEL_EXEC_INFO_WORKGROUP_BATCH_SIZE_ARM 0x41E5 #define CL_KERNEL_EXEC_INFO_WORKGROUP_BATCH_SIZE_MODIFIER_ARM 0x41E6 #define CL_KERNEL_EXEC_INFO_WARP_COUNT_LIMIT_ARM 0x41E8 #define CL_KERNEL_EXEC_INFO_COMPUTE_UNIT_MAX_QUEUED_BATCHES_ARM 0x41F1 /* cl_kernel_info */ #define CL_KERNEL_MAX_WARP_COUNT_ARM 0x41E9 /* cl_queue_properties */ #define CL_QUEUE_KERNEL_BATCHING_ARM 0x41E7 #define CL_QUEUE_DEFERRED_FLUSH_ARM 0x41EC /*************************************************************** * cl_arm_controlled_kernel_termination ***************************************************************/ #define cl_arm_controlled_kernel_termination 1 #define CL_ARM_CONTROLLED_KERNEL_TERMINATION_EXTENSION_NAME \ "cl_arm_controlled_kernel_termination" /* Types */ typedef cl_bitfield cl_device_controlled_termination_capabilities_arm; /* Error codes */ #define CL_COMMAND_TERMINATED_ITSELF_WITH_FAILURE_ARM -1108 /* cl_device_controlled_termination_capabilities_arm */ #define CL_DEVICE_CONTROLLED_TERMINATION_SUCCESS_ARM (1 << 0) #define CL_DEVICE_CONTROLLED_TERMINATION_FAILURE_ARM (1 << 1) #define CL_DEVICE_CONTROLLED_TERMINATION_QUERY_ARM (1 << 2) /* cl_device_info */ #define CL_DEVICE_CONTROLLED_TERMINATION_CAPABILITIES_ARM 0x41EE /* cl_event_info */ #define CL_EVENT_COMMAND_TERMINATION_REASON_ARM 0x41ED /* cl_command_termination_reason_arm */ #define CL_COMMAND_TERMINATION_COMPLETION_ARM 0 #define CL_COMMAND_TERMINATION_CONTROLLED_SUCCESS_ARM 1 #define CL_COMMAND_TERMINATION_CONTROLLED_FAILURE_ARM 2 #define CL_COMMAND_TERMINATION_ERROR_ARM 3 /*************************************************************** * cl_arm_protected_memory_allocation ***************************************************************/ #define cl_arm_protected_memory_allocation 1 #define CL_ARM_PROTECTED_MEMORY_ALLOCATION_EXTENSION_NAME \ "cl_arm_protected_memory_allocation" #define CL_MEM_PROTECTED_ALLOC_ARM ((cl_bitfield)1 << 36) /*************************************************************** * cl_intel_exec_by_local_thread ***************************************************************/ #define cl_intel_exec_by_local_thread 1 #define CL_INTEL_EXEC_BY_LOCAL_THREAD_EXTENSION_NAME \ "cl_intel_exec_by_local_thread" /* cl_command_queue_properties - bitfield */ #define CL_QUEUE_THREAD_LOCAL_EXEC_ENABLE_INTEL ((cl_bitfield)1 << 31) /*************************************************************** * cl_intel_device_attribute_query ***************************************************************/ #define cl_intel_device_attribute_query 1 #define CL_INTEL_DEVICE_ATTRIBUTE_QUERY_EXTENSION_NAME \ "cl_intel_device_attribute_query" typedef cl_bitfield cl_device_feature_capabilities_intel; /* cl_device_feature_capabilities_intel */ #define CL_DEVICE_FEATURE_FLAG_DP4A_INTEL (1 << 0) #define CL_DEVICE_FEATURE_FLAG_DPAS_INTEL (1 << 1) /* cl_device_info */ #define CL_DEVICE_IP_VERSION_INTEL 0x4250 #define CL_DEVICE_ID_INTEL 0x4251 #define CL_DEVICE_NUM_SLICES_INTEL 0x4252 #define CL_DEVICE_NUM_SUB_SLICES_PER_SLICE_INTEL 0x4253 #define CL_DEVICE_NUM_EUS_PER_SUB_SLICE_INTEL 0x4254 #define CL_DEVICE_NUM_THREADS_PER_EU_INTEL 0x4255 #define CL_DEVICE_FEATURE_CAPABILITIES_INTEL 0x4256 /*************************************************************** * cl_intel_device_partition_by_names ***************************************************************/ #define cl_intel_device_partition_by_names 1 #define CL_INTEL_DEVICE_PARTITION_BY_NAMES_EXTENSION_NAME \ "cl_intel_device_partition_by_names" #define CL_DEVICE_PARTITION_BY_NAMES_INTEL 0x4052 #define CL_PARTITION_BY_NAMES_LIST_END_INTEL -1 /*************************************************************** * cl_intel_accelerator ***************************************************************/ #define cl_intel_accelerator 1 #define CL_INTEL_ACCELERATOR_EXTENSION_NAME \ "cl_intel_accelerator" typedef struct _cl_accelerator_intel* cl_accelerator_intel; typedef cl_uint cl_accelerator_type_intel; typedef cl_uint cl_accelerator_info_intel; /* cl_accelerator_info_intel */ #define CL_ACCELERATOR_DESCRIPTOR_INTEL 0x4090 #define CL_ACCELERATOR_REFERENCE_COUNT_INTEL 0x4091 #define CL_ACCELERATOR_CONTEXT_INTEL 0x4092 #define CL_ACCELERATOR_TYPE_INTEL 0x4093 /* Error codes */ #define CL_INVALID_ACCELERATOR_INTEL -1094 #define CL_INVALID_ACCELERATOR_TYPE_INTEL -1095 #define CL_INVALID_ACCELERATOR_DESCRIPTOR_INTEL -1096 #define CL_ACCELERATOR_TYPE_NOT_SUPPORTED_INTEL -1097 typedef cl_accelerator_intel (CL_API_CALL * clCreateAcceleratorINTEL_fn)( cl_context context, cl_accelerator_type_intel accelerator_type, size_t descriptor_size, const void* descriptor, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; typedef cl_int (CL_API_CALL * clGetAcceleratorInfoINTEL_fn)( cl_accelerator_intel accelerator, cl_accelerator_info_intel 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 * clRetainAcceleratorINTEL_fn)( cl_accelerator_intel accelerator) CL_API_SUFFIX__VERSION_1_2; typedef cl_int (CL_API_CALL * clReleaseAcceleratorINTEL_fn)( cl_accelerator_intel accelerator) CL_API_SUFFIX__VERSION_1_2; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_accelerator_intel CL_API_CALL clCreateAcceleratorINTEL( cl_context context, cl_accelerator_type_intel accelerator_type, size_t descriptor_size, const void* descriptor, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; extern CL_API_ENTRY cl_int CL_API_CALL clGetAcceleratorInfoINTEL( cl_accelerator_intel accelerator, cl_accelerator_info_intel param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_2; extern CL_API_ENTRY cl_int CL_API_CALL clRetainAcceleratorINTEL( cl_accelerator_intel accelerator) CL_API_SUFFIX__VERSION_1_2; extern CL_API_ENTRY cl_int CL_API_CALL clReleaseAcceleratorINTEL( cl_accelerator_intel accelerator) CL_API_SUFFIX__VERSION_1_2; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_intel_motion_estimation ***************************************************************/ #define cl_intel_motion_estimation 1 #define CL_INTEL_MOTION_ESTIMATION_EXTENSION_NAME \ "cl_intel_motion_estimation" typedef struct _cl_motion_estimation_desc_intel { cl_uint mb_block_type; cl_uint subpixel_mode; cl_uint sad_adjust_mode; cl_uint search_path_type; } cl_motion_estimation_desc_intel; /* cl_accelerator_type_intel */ #define CL_ACCELERATOR_TYPE_MOTION_ESTIMATION_INTEL 0x0 /* cl_uint mb_block_type */ #define CL_ME_MB_TYPE_16x16_INTEL 0x0 #define CL_ME_MB_TYPE_8x8_INTEL 0x1 #define CL_ME_MB_TYPE_4x4_INTEL 0x2 /* cl_uint subpixel_mode */ #define CL_ME_SUBPIXEL_MODE_INTEGER_INTEL 0x0 #define CL_ME_SUBPIXEL_MODE_HPEL_INTEL 0x1 #define CL_ME_SUBPIXEL_MODE_QPEL_INTEL 0x2 /* cl_uint sad_adjust_mode */ #define CL_ME_SAD_ADJUST_MODE_NONE_INTEL 0x0 #define CL_ME_SAD_ADJUST_MODE_HAAR_INTEL 0x1 /* cl_uint search_path_type */ #define CL_ME_SEARCH_PATH_RADIUS_2_2_INTEL 0x0 #define CL_ME_SEARCH_PATH_RADIUS_4_4_INTEL 0x1 #define CL_ME_SEARCH_PATH_RADIUS_16_12_INTEL 0x5 /*************************************************************** * cl_intel_advanced_motion_estimation ***************************************************************/ #define cl_intel_advanced_motion_estimation 1 #define CL_INTEL_ADVANCED_MOTION_ESTIMATION_EXTENSION_NAME \ "cl_intel_advanced_motion_estimation" /* cl_device_info */ #define CL_DEVICE_ME_VERSION_INTEL 0x407E #define CL_ME_VERSION_LEGACY_INTEL 0x0 #define CL_ME_VERSION_ADVANCED_VER_1_INTEL 0x1 #define CL_ME_VERSION_ADVANCED_VER_2_INTEL 0x2 #define CL_ME_CHROMA_INTRA_PREDICT_ENABLED_INTEL 0x1 #define CL_ME_LUMA_INTRA_PREDICT_ENABLED_INTEL 0x2 #define CL_ME_SKIP_BLOCK_TYPE_16x16_INTEL 0x0 #define CL_ME_SKIP_BLOCK_TYPE_8x8_INTEL 0x1 #define CL_ME_COST_PENALTY_NONE_INTEL 0x0 #define CL_ME_COST_PENALTY_LOW_INTEL 0x1 #define CL_ME_COST_PENALTY_NORMAL_INTEL 0x2 #define CL_ME_COST_PENALTY_HIGH_INTEL 0x3 #define CL_ME_COST_PRECISION_QPEL_INTEL 0x0 #define CL_ME_COST_PRECISION_HPEL_INTEL 0x1 #define CL_ME_COST_PRECISION_PEL_INTEL 0x2 #define CL_ME_COST_PRECISION_DPEL_INTEL 0x3 #define CL_ME_LUMA_PREDICTOR_MODE_VERTICAL_INTEL 0x0 #define CL_ME_LUMA_PREDICTOR_MODE_HORIZONTAL_INTEL 0x1 #define CL_ME_LUMA_PREDICTOR_MODE_DC_INTEL 0x2 #define CL_ME_LUMA_PREDICTOR_MODE_DIAGONAL_DOWN_LEFT_INTEL 0x3 #define CL_ME_LUMA_PREDICTOR_MODE_DIAGONAL_DOWN_RIGHT_INTEL 0x4 #define CL_ME_LUMA_PREDICTOR_MODE_PLANE_INTEL 0x4 #define CL_ME_LUMA_PREDICTOR_MODE_VERTICAL_RIGHT_INTEL 0x5 #define CL_ME_LUMA_PREDICTOR_MODE_HORIZONTAL_DOWN_INTEL 0x6 #define CL_ME_LUMA_PREDICTOR_MODE_VERTICAL_LEFT_INTEL 0x7 #define CL_ME_LUMA_PREDICTOR_MODE_HORIZONTAL_UP_INTEL 0x8 #define CL_ME_CHROMA_PREDICTOR_MODE_DC_INTEL 0x0 #define CL_ME_CHROMA_PREDICTOR_MODE_HORIZONTAL_INTEL 0x1 #define CL_ME_CHROMA_PREDICTOR_MODE_VERTICAL_INTEL 0x2 #define CL_ME_CHROMA_PREDICTOR_MODE_PLANE_INTEL 0x3 #define CL_ME_FORWARD_INPUT_MODE_INTEL 0x1 #define CL_ME_BACKWARD_INPUT_MODE_INTEL 0x2 #define CL_ME_BIDIRECTION_INPUT_MODE_INTEL 0x3 #define CL_ME_BIDIR_WEIGHT_QUARTER_INTEL 16 #define CL_ME_BIDIR_WEIGHT_THIRD_INTEL 21 #define CL_ME_BIDIR_WEIGHT_HALF_INTEL 32 #define CL_ME_BIDIR_WEIGHT_TWO_THIRD_INTEL 43 #define CL_ME_BIDIR_WEIGHT_THREE_QUARTER_INTEL 48 /*************************************************************** * cl_intel_simultaneous_sharing ***************************************************************/ #define cl_intel_simultaneous_sharing 1 #define CL_INTEL_SIMULTANEOUS_SHARING_EXTENSION_NAME \ "cl_intel_simultaneous_sharing" /* cl_device_info */ #define CL_DEVICE_SIMULTANEOUS_INTEROPS_INTEL 0x4104 #define CL_DEVICE_NUM_SIMULTANEOUS_INTEROPS_INTEL 0x4105 /*************************************************************** * cl_intel_egl_image_yuv ***************************************************************/ #define cl_intel_egl_image_yuv 1 #define CL_INTEL_EGL_IMAGE_YUV_EXTENSION_NAME \ "cl_intel_egl_image_yuv" /* cl_egl_image_properties_khr */ #define CL_EGL_YUV_PLANE_INTEL 0x4107 /*************************************************************** * cl_intel_packed_yuv ***************************************************************/ #define cl_intel_packed_yuv 1 #define CL_INTEL_PACKED_YUV_EXTENSION_NAME \ "cl_intel_packed_yuv" /* cl_channel_order */ #define CL_YUYV_INTEL 0x4076 #define CL_UYVY_INTEL 0x4077 #define CL_YVYU_INTEL 0x4078 #define CL_VYUY_INTEL 0x4079 /*************************************************************** * cl_intel_required_subgroup_size ***************************************************************/ #define cl_intel_required_subgroup_size 1 #define CL_INTEL_REQUIRED_SUBGROUP_SIZE_EXTENSION_NAME \ "cl_intel_required_subgroup_size" /* cl_device_info */ #define CL_DEVICE_SUB_GROUP_SIZES_INTEL 0x4108 /* cl_kernel_work_group_info */ #define CL_KERNEL_SPILL_MEM_SIZE_INTEL 0x4109 /* cl_kernel_sub_group_info */ #define CL_KERNEL_COMPILE_SUB_GROUP_SIZE_INTEL 0x410A /*************************************************************** * cl_intel_driver_diagnostics ***************************************************************/ #define cl_intel_driver_diagnostics 1 #define CL_INTEL_DRIVER_DIAGNOSTICS_EXTENSION_NAME \ "cl_intel_driver_diagnostics" typedef cl_uint cl_diagnostics_verbose_level; /* cl_context_properties */ #define CL_CONTEXT_SHOW_DIAGNOSTICS_INTEL 0x4106 #define CL_CONTEXT_DIAGNOSTICS_LEVEL_ALL_INTEL 0xff #define CL_CONTEXT_DIAGNOSTICS_LEVEL_GOOD_INTEL (1 << 0) #define CL_CONTEXT_DIAGNOSTICS_LEVEL_BAD_INTEL (1 << 1) #define CL_CONTEXT_DIAGNOSTICS_LEVEL_NEUTRAL_INTEL (1 << 2) /*************************************************************** * cl_intel_planar_yuv ***************************************************************/ #define cl_intel_planar_yuv 1 #define CL_INTEL_PLANAR_YUV_EXTENSION_NAME \ "cl_intel_planar_yuv" /* cl_channel_order */ #define CL_NV12_INTEL 0x410E /* cl_mem_flags */ #define CL_MEM_NO_ACCESS_INTEL (1 << 24) #define CL_MEM_ACCESS_FLAGS_UNRESTRICTED_INTEL (1 << 25) /* cl_device_info */ #define CL_DEVICE_PLANAR_YUV_MAX_WIDTH_INTEL 0x417E #define CL_DEVICE_PLANAR_YUV_MAX_HEIGHT_INTEL 0x417F /*************************************************************** * cl_intel_device_side_avc_motion_estimation ***************************************************************/ #define cl_intel_device_side_avc_motion_estimation 1 #define CL_INTEL_DEVICE_SIDE_AVC_MOTION_ESTIMATION_EXTENSION_NAME \ "cl_intel_device_side_avc_motion_estimation" /* cl_device_info */ #define CL_DEVICE_AVC_ME_VERSION_INTEL 0x410B #define CL_DEVICE_AVC_ME_SUPPORTS_TEXTURE_SAMPLER_USE_INTEL 0x410C #define CL_DEVICE_AVC_ME_SUPPORTS_PREEMPTION_INTEL 0x410D /* returned by CL_DEVICE_AVC_ME_VERSION_INTEL */ #define CL_AVC_ME_VERSION_0_INTEL 0x0 #define CL_AVC_ME_VERSION_1_INTEL 0x1 /* Inter macro-block major shape values */ #define CL_AVC_ME_MAJOR_16x16_INTEL 0x0 #define CL_AVC_ME_MAJOR_16x8_INTEL 0x1 #define CL_AVC_ME_MAJOR_8x16_INTEL 0x2 #define CL_AVC_ME_MAJOR_8x8_INTEL 0x3 /* Inter macro-block minor shape values */ #define CL_AVC_ME_MINOR_8x8_INTEL 0x0 #define CL_AVC_ME_MINOR_8x4_INTEL 0x1 #define CL_AVC_ME_MINOR_4x8_INTEL 0x2 #define CL_AVC_ME_MINOR_4x4_INTEL 0x3 /* Inter macro-block major direction values */ #define CL_AVC_ME_MAJOR_FORWARD_INTEL 0x0 #define CL_AVC_ME_MAJOR_BACKWARD_INTEL 0x1 #define CL_AVC_ME_MAJOR_BIDIRECTIONAL_INTEL 0x2 /* Inter (IME) partition mask values */ #define CL_AVC_ME_PARTITION_MASK_ALL_INTEL 0x0 #define CL_AVC_ME_PARTITION_MASK_16x16_INTEL 0x7E #define CL_AVC_ME_PARTITION_MASK_16x8_INTEL 0x7D #define CL_AVC_ME_PARTITION_MASK_8x16_INTEL 0x7B #define CL_AVC_ME_PARTITION_MASK_8x8_INTEL 0x77 #define CL_AVC_ME_PARTITION_MASK_8x4_INTEL 0x6F #define CL_AVC_ME_PARTITION_MASK_4x8_INTEL 0x5F #define CL_AVC_ME_PARTITION_MASK_4x4_INTEL 0x3F /* Search window configuration */ #define CL_AVC_ME_SEARCH_WINDOW_EXHAUSTIVE_INTEL 0x0 #define CL_AVC_ME_SEARCH_WINDOW_SMALL_INTEL 0x1 #define CL_AVC_ME_SEARCH_WINDOW_TINY_INTEL 0x2 #define CL_AVC_ME_SEARCH_WINDOW_EXTRA_TINY_INTEL 0x3 #define CL_AVC_ME_SEARCH_WINDOW_DIAMOND_INTEL 0x4 #define CL_AVC_ME_SEARCH_WINDOW_LARGE_DIAMOND_INTEL 0x5 #define CL_AVC_ME_SEARCH_WINDOW_RESERVED0_INTEL 0x6 #define CL_AVC_ME_SEARCH_WINDOW_RESERVED1_INTEL 0x7 #define CL_AVC_ME_SEARCH_WINDOW_CUSTOM_INTEL 0x8 #define CL_AVC_ME_SEARCH_WINDOW_16x12_RADIUS_INTEL 0x9 #define CL_AVC_ME_SEARCH_WINDOW_4x4_RADIUS_INTEL 0x2 #define CL_AVC_ME_SEARCH_WINDOW_2x2_RADIUS_INTEL 0xa /* SAD adjustment mode */ #define CL_AVC_ME_SAD_ADJUST_MODE_NONE_INTEL 0x0 #define CL_AVC_ME_SAD_ADJUST_MODE_HAAR_INTEL 0x2 /* Pixel resolution */ #define CL_AVC_ME_SUBPIXEL_MODE_INTEGER_INTEL 0x0 #define CL_AVC_ME_SUBPIXEL_MODE_HPEL_INTEL 0x1 #define CL_AVC_ME_SUBPIXEL_MODE_QPEL_INTEL 0x3 /* Cost precision values */ #define CL_AVC_ME_COST_PRECISION_QPEL_INTEL 0x0 #define CL_AVC_ME_COST_PRECISION_HPEL_INTEL 0x1 #define CL_AVC_ME_COST_PRECISION_PEL_INTEL 0x2 #define CL_AVC_ME_COST_PRECISION_DPEL_INTEL 0x3 /* Inter bidirectional weights */ #define CL_AVC_ME_BIDIR_WEIGHT_QUARTER_INTEL 0x10 #define CL_AVC_ME_BIDIR_WEIGHT_THIRD_INTEL 0x15 #define CL_AVC_ME_BIDIR_WEIGHT_HALF_INTEL 0x20 #define CL_AVC_ME_BIDIR_WEIGHT_TWO_THIRD_INTEL 0x2B #define CL_AVC_ME_BIDIR_WEIGHT_THREE_QUARTER_INTEL 0x30 /* Inter border reached values */ #define CL_AVC_ME_BORDER_REACHED_LEFT_INTEL 0x0 #define CL_AVC_ME_BORDER_REACHED_RIGHT_INTEL 0x2 #define CL_AVC_ME_BORDER_REACHED_TOP_INTEL 0x4 #define CL_AVC_ME_BORDER_REACHED_BOTTOM_INTEL 0x8 /* Inter skip block partition type */ #define CL_AVC_ME_SKIP_BLOCK_PARTITION_16x16_INTEL 0x0 #define CL_AVC_ME_SKIP_BLOCK_PARTITION_8x8_INTEL 0x4000 /* Inter skip motion vector mask */ #define CL_AVC_ME_SKIP_BLOCK_16x16_FORWARD_ENABLE_INTEL (0x1 << 24) #define CL_AVC_ME_SKIP_BLOCK_16x16_BACKWARD_ENABLE_INTEL (0x2 << 24) #define CL_AVC_ME_SKIP_BLOCK_16x16_DUAL_ENABLE_INTEL (0x3 << 24) #define CL_AVC_ME_SKIP_BLOCK_8x8_FORWARD_ENABLE_INTEL (0x55 << 24) #define CL_AVC_ME_SKIP_BLOCK_8x8_BACKWARD_ENABLE_INTEL (0xAA << 24) #define CL_AVC_ME_SKIP_BLOCK_8x8_DUAL_ENABLE_INTEL (0xFF << 24) #define CL_AVC_ME_SKIP_BLOCK_8x8_0_FORWARD_ENABLE_INTEL (0x1 << 24) #define CL_AVC_ME_SKIP_BLOCK_8x8_0_BACKWARD_ENABLE_INTEL (0x2 << 24) #define CL_AVC_ME_SKIP_BLOCK_8x8_1_FORWARD_ENABLE_INTEL (0x1 << 26) #define CL_AVC_ME_SKIP_BLOCK_8x8_1_BACKWARD_ENABLE_INTEL (0x2 << 26) #define CL_AVC_ME_SKIP_BLOCK_8x8_2_FORWARD_ENABLE_INTEL (0x1 << 28) #define CL_AVC_ME_SKIP_BLOCK_8x8_2_BACKWARD_ENABLE_INTEL (0x2 << 28) #define CL_AVC_ME_SKIP_BLOCK_8x8_3_FORWARD_ENABLE_INTEL (0x1 << 30) #define CL_AVC_ME_SKIP_BLOCK_8x8_3_BACKWARD_ENABLE_INTEL (0x2 << 30) /* Block based skip type values */ #define CL_AVC_ME_BLOCK_BASED_SKIP_4x4_INTEL 0x00 #define CL_AVC_ME_BLOCK_BASED_SKIP_8x8_INTEL 0x80 /* cl_intel_device_side_avc_motion_estimation.?? */ #define CL_AVC_ME_INTRA_16x16_INTEL 0x0 #define CL_AVC_ME_INTRA_8x8_INTEL 0x1 #define CL_AVC_ME_INTRA_4x4_INTEL 0x2 /* Luma intra partition mask values */ #define CL_AVC_ME_INTRA_LUMA_PARTITION_MASK_16x16_INTEL 0x6 #define CL_AVC_ME_INTRA_LUMA_PARTITION_MASK_8x8_INTEL 0x5 #define CL_AVC_ME_INTRA_LUMA_PARTITION_MASK_4x4_INTEL 0x3 /* Intra neighbor availability mask values */ #define CL_AVC_ME_INTRA_NEIGHBOR_LEFT_MASK_ENABLE_INTEL 0x60 #define CL_AVC_ME_INTRA_NEIGHBOR_UPPER_MASK_ENABLE_INTEL 0x10 #define CL_AVC_ME_INTRA_NEIGHBOR_UPPER_RIGHT_MASK_ENABLE_INTEL 0x8 #define CL_AVC_ME_INTRA_NEIGHBOR_UPPER_LEFT_MASK_ENABLE_INTEL 0x4 /* Luma intra modes */ #define CL_AVC_ME_LUMA_PREDICTOR_MODE_VERTICAL_INTEL 0x0 #define CL_AVC_ME_LUMA_PREDICTOR_MODE_HORIZONTAL_INTEL 0x1 #define CL_AVC_ME_LUMA_PREDICTOR_MODE_DC_INTEL 0x2 #define CL_AVC_ME_LUMA_PREDICTOR_MODE_DIAGONAL_DOWN_LEFT_INTEL 0x3 #define CL_AVC_ME_LUMA_PREDICTOR_MODE_DIAGONAL_DOWN_RIGHT_INTEL 0x4 #define CL_AVC_ME_LUMA_PREDICTOR_MODE_PLANE_INTEL 0x4 #define CL_AVC_ME_LUMA_PREDICTOR_MODE_VERTICAL_RIGHT_INTEL 0x5 #define CL_AVC_ME_LUMA_PREDICTOR_MODE_HORIZONTAL_DOWN_INTEL 0x6 #define CL_AVC_ME_LUMA_PREDICTOR_MODE_VERTICAL_LEFT_INTEL 0x7 #define CL_AVC_ME_LUMA_PREDICTOR_MODE_HORIZONTAL_UP_INTEL 0x8 /* Chroma intra modes */ #define CL_AVC_ME_CHROMA_PREDICTOR_MODE_DC_INTEL 0x0 #define CL_AVC_ME_CHROMA_PREDICTOR_MODE_HORIZONTAL_INTEL 0x1 #define CL_AVC_ME_CHROMA_PREDICTOR_MODE_VERTICAL_INTEL 0x2 #define CL_AVC_ME_CHROMA_PREDICTOR_MODE_PLANE_INTEL 0x3 /* Reference image select values */ #define CL_AVC_ME_FRAME_FORWARD_INTEL 0x1 #define CL_AVC_ME_FRAME_BACKWARD_INTEL 0x2 #define CL_AVC_ME_FRAME_DUAL_INTEL 0x3 /* Slice type values */ #define CL_AVC_ME_SLICE_TYPE_PRED_INTEL 0x0 #define CL_AVC_ME_SLICE_TYPE_BPRED_INTEL 0x1 #define CL_AVC_ME_SLICE_TYPE_INTRA_INTEL 0x2 /* Interlaced image field polarity values */ #define CL_AVC_ME_INTERLACED_SCAN_TOP_FIELD_INTEL 0x0 #define CL_AVC_ME_INTERLACED_SCAN_BOTTOM_FIELD_INTEL 0x1 /*************************************************************** * cl_intel_unified_shared_memory ***************************************************************/ #define cl_intel_unified_shared_memory 1 #define CL_INTEL_UNIFIED_SHARED_MEMORY_EXTENSION_NAME \ "cl_intel_unified_shared_memory" typedef cl_bitfield cl_device_unified_shared_memory_capabilities_intel; typedef cl_properties cl_mem_properties_intel; typedef cl_bitfield cl_mem_alloc_flags_intel; typedef cl_uint cl_mem_info_intel; typedef cl_uint cl_unified_shared_memory_type_intel; typedef cl_uint cl_mem_advice_intel; /* cl_device_info */ #define CL_DEVICE_HOST_MEM_CAPABILITIES_INTEL 0x4190 #define CL_DEVICE_DEVICE_MEM_CAPABILITIES_INTEL 0x4191 #define CL_DEVICE_SINGLE_DEVICE_SHARED_MEM_CAPABILITIES_INTEL 0x4192 #define CL_DEVICE_CROSS_DEVICE_SHARED_MEM_CAPABILITIES_INTEL 0x4193 #define CL_DEVICE_SHARED_SYSTEM_MEM_CAPABILITIES_INTEL 0x4194 /* cl_unified_shared_memory_capabilities_intel - bitfield */ #define CL_UNIFIED_SHARED_MEMORY_ACCESS_INTEL (1 << 0) #define CL_UNIFIED_SHARED_MEMORY_ATOMIC_ACCESS_INTEL (1 << 1) #define CL_UNIFIED_SHARED_MEMORY_CONCURRENT_ACCESS_INTEL (1 << 2) #define CL_UNIFIED_SHARED_MEMORY_CONCURRENT_ATOMIC_ACCESS_INTEL (1 << 3) /* cl_mem_properties_intel */ #define CL_MEM_ALLOC_FLAGS_INTEL 0x4195 /* cl_mem_alloc_flags_intel - bitfield */ #define CL_MEM_ALLOC_WRITE_COMBINED_INTEL (1 << 0) #define CL_MEM_ALLOC_INITIAL_PLACEMENT_DEVICE_INTEL (1 << 1) #define CL_MEM_ALLOC_INITIAL_PLACEMENT_HOST_INTEL (1 << 2) /* cl_mem_alloc_info_intel */ #define CL_MEM_ALLOC_TYPE_INTEL 0x419A #define CL_MEM_ALLOC_BASE_PTR_INTEL 0x419B #define CL_MEM_ALLOC_SIZE_INTEL 0x419C #define CL_MEM_ALLOC_DEVICE_INTEL 0x419D /* cl_unified_shared_memory_type_intel */ #define CL_MEM_TYPE_UNKNOWN_INTEL 0x4196 #define CL_MEM_TYPE_HOST_INTEL 0x4197 #define CL_MEM_TYPE_DEVICE_INTEL 0x4198 #define CL_MEM_TYPE_SHARED_INTEL 0x4199 /* cl_kernel_exec_info */ #define CL_KERNEL_EXEC_INFO_INDIRECT_HOST_ACCESS_INTEL 0x4200 #define CL_KERNEL_EXEC_INFO_INDIRECT_DEVICE_ACCESS_INTEL 0x4201 #define CL_KERNEL_EXEC_INFO_INDIRECT_SHARED_ACCESS_INTEL 0x4202 #define CL_KERNEL_EXEC_INFO_USM_PTRS_INTEL 0x4203 /* cl_command_type */ #define CL_COMMAND_MEMFILL_INTEL 0x4204 #define CL_COMMAND_MEMCPY_INTEL 0x4205 #define CL_COMMAND_MIGRATEMEM_INTEL 0x4206 #define CL_COMMAND_MEMADVISE_INTEL 0x4207 typedef void* (CL_API_CALL * clHostMemAllocINTEL_fn)( cl_context context, const cl_mem_properties_intel* properties, size_t size, cl_uint alignment, cl_int* errcode_ret) ; typedef void* (CL_API_CALL * clDeviceMemAllocINTEL_fn)( cl_context context, cl_device_id device, const cl_mem_properties_intel* properties, size_t size, cl_uint alignment, cl_int* errcode_ret) ; typedef void* (CL_API_CALL * clSharedMemAllocINTEL_fn)( cl_context context, cl_device_id device, const cl_mem_properties_intel* properties, size_t size, cl_uint alignment, cl_int* errcode_ret) ; typedef cl_int (CL_API_CALL * clMemFreeINTEL_fn)( cl_context context, void* ptr) ; typedef cl_int (CL_API_CALL * clMemBlockingFreeINTEL_fn)( cl_context context, void* ptr) ; typedef cl_int (CL_API_CALL * clGetMemAllocInfoINTEL_fn)( cl_context context, const void* ptr, cl_mem_info_intel param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret) ; typedef cl_int (CL_API_CALL * clSetKernelArgMemPointerINTEL_fn)( cl_kernel kernel, cl_uint arg_index, const void* arg_value) ; typedef cl_int (CL_API_CALL * clEnqueueMemFillINTEL_fn)( cl_command_queue command_queue, void* dst_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) ; typedef cl_int (CL_API_CALL * clEnqueueMemcpyINTEL_fn)( cl_command_queue command_queue, cl_bool blocking, 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) ; typedef cl_int (CL_API_CALL * clEnqueueMemAdviseINTEL_fn)( cl_command_queue command_queue, const void* ptr, size_t size, cl_mem_advice_intel advice, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event) ; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY void* CL_API_CALL clHostMemAllocINTEL( cl_context context, const cl_mem_properties_intel* properties, size_t size, cl_uint alignment, cl_int* errcode_ret) ; extern CL_API_ENTRY void* CL_API_CALL clDeviceMemAllocINTEL( cl_context context, cl_device_id device, const cl_mem_properties_intel* properties, size_t size, cl_uint alignment, cl_int* errcode_ret) ; extern CL_API_ENTRY void* CL_API_CALL clSharedMemAllocINTEL( cl_context context, cl_device_id device, const cl_mem_properties_intel* properties, size_t size, cl_uint alignment, cl_int* errcode_ret) ; extern CL_API_ENTRY cl_int CL_API_CALL clMemFreeINTEL( cl_context context, void* ptr) ; extern CL_API_ENTRY cl_int CL_API_CALL clMemBlockingFreeINTEL( cl_context context, void* ptr) ; extern CL_API_ENTRY cl_int CL_API_CALL clGetMemAllocInfoINTEL( cl_context context, const void* ptr, cl_mem_info_intel param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret) ; extern CL_API_ENTRY cl_int CL_API_CALL clSetKernelArgMemPointerINTEL( cl_kernel kernel, cl_uint arg_index, const void* arg_value) ; extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueMemFillINTEL( cl_command_queue command_queue, void* dst_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) ; extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueMemcpyINTEL( cl_command_queue command_queue, cl_bool blocking, 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) ; extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueMemAdviseINTEL( cl_command_queue command_queue, const void* ptr, size_t size, cl_mem_advice_intel advice, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event) ; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ #if defined(CL_VERSION_1_2) /* Requires OpenCL 1.2 for cl_mem_migration_flags: */ typedef cl_int (CL_API_CALL * clEnqueueMigrateMemINTEL_fn)( cl_command_queue command_queue, const void* ptr, size_t size, cl_mem_migration_flags flags, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event) ; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueMigrateMemINTEL( cl_command_queue command_queue, const void* ptr, size_t size, cl_mem_migration_flags flags, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event) ; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ #endif /* defined(CL_VERSION_1_2) */ /* deprecated, use clEnqueueMemFillINTEL instead */ typedef cl_int (CL_API_CALL * clEnqueueMemsetINTEL_fn)( cl_command_queue command_queue, void* dst_ptr, cl_int value, size_t size, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event) ; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueMemsetINTEL( cl_command_queue command_queue, void* dst_ptr, cl_int value, size_t size, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event) ; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_intel_mem_alloc_buffer_location ***************************************************************/ #define cl_intel_mem_alloc_buffer_location 1 #define CL_INTEL_MEM_ALLOC_BUFFER_LOCATION_EXTENSION_NAME \ "cl_intel_mem_alloc_buffer_location" /* cl_mem_properties_intel */ #define CL_MEM_ALLOC_BUFFER_LOCATION_INTEL 0x419E /* cl_mem_alloc_info_intel */ /* enum CL_MEM_ALLOC_BUFFER_LOCATION_INTEL */ /*************************************************************** * cl_intel_create_buffer_with_properties ***************************************************************/ #define cl_intel_create_buffer_with_properties 1 #define CL_INTEL_CREATE_BUFFER_WITH_PROPERTIES_EXTENSION_NAME \ "cl_intel_create_buffer_with_properties" /* type cl_mem_properties_intel */ typedef cl_mem (CL_API_CALL * clCreateBufferWithPropertiesINTEL_fn)( cl_context context, const cl_mem_properties_intel* properties, cl_mem_flags flags, size_t size, void* host_ptr, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_mem CL_API_CALL clCreateBufferWithPropertiesINTEL( cl_context context, const cl_mem_properties_intel* properties, cl_mem_flags flags, size_t size, void* host_ptr, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_intel_program_scope_host_pipe ***************************************************************/ #define cl_intel_program_scope_host_pipe 1 #define CL_INTEL_PROGRAM_SCOPE_HOST_PIPE_EXTENSION_NAME \ "cl_intel_program_scope_host_pipe" /* clGetEventInfo response when param_name is CL_EVENT_COMMAND_TYPE */ #define CL_COMMAND_READ_HOST_PIPE_INTEL 0x4214 #define CL_COMMAND_WRITE_HOST_PIPE_INTEL 0x4215 /* clGetProgramInfo param_name */ #define CL_PROGRAM_NUM_HOST_PIPES_INTEL 0x4216 #define CL_PROGRAM_HOST_PIPE_NAMES_INTEL 0x4217 typedef cl_int (CL_API_CALL * clEnqueueReadHostPipeINTEL_fn)( cl_command_queue command_queue, cl_program program, const char* pipe_symbol, cl_bool blocking_read, void* ptr, size_t 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 * clEnqueueWriteHostPipeINTEL_fn)( cl_command_queue command_queue, cl_program program, const char* pipe_symbol, cl_bool blocking_write, const void* ptr, size_t size, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event) CL_API_SUFFIX__VERSION_1_0; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadHostPipeINTEL( cl_command_queue command_queue, cl_program program, const char* pipe_symbol, cl_bool blocking_read, void* ptr, size_t size, 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 clEnqueueWriteHostPipeINTEL( cl_command_queue command_queue, cl_program program, const char* pipe_symbol, cl_bool blocking_write, const void* ptr, size_t size, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event) CL_API_SUFFIX__VERSION_1_0; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_intel_mem_channel_property ***************************************************************/ #define cl_intel_mem_channel_property 1 #define CL_INTEL_MEM_CHANNEL_PROPERTY_EXTENSION_NAME \ "cl_intel_mem_channel_property" /* cl_mem_properties_intel */ #define CL_MEM_CHANNEL_INTEL 0x4213 /*************************************************************** * cl_intel_mem_force_host_memory ***************************************************************/ #define cl_intel_mem_force_host_memory 1 #define CL_INTEL_MEM_FORCE_HOST_MEMORY_EXTENSION_NAME \ "cl_intel_mem_force_host_memory" /* cl_mem_flags */ #define CL_MEM_FORCE_HOST_MEMORY_INTEL (1 << 20) /*************************************************************** * cl_intel_command_queue_families ***************************************************************/ #define cl_intel_command_queue_families 1 #define CL_INTEL_COMMAND_QUEUE_FAMILIES_EXTENSION_NAME \ "cl_intel_command_queue_families" typedef cl_bitfield cl_command_queue_capabilities_intel; #define CL_QUEUE_FAMILY_MAX_NAME_SIZE_INTEL 64 typedef struct _cl_queue_family_properties_intel { cl_command_queue_properties properties; cl_command_queue_capabilities_intel capabilities; cl_uint count; char name[CL_QUEUE_FAMILY_MAX_NAME_SIZE_INTEL]; } cl_queue_family_properties_intel; /* cl_device_info */ #define CL_DEVICE_QUEUE_FAMILY_PROPERTIES_INTEL 0x418B /* cl_queue_properties */ #define CL_QUEUE_FAMILY_INTEL 0x418C #define CL_QUEUE_INDEX_INTEL 0x418D /* cl_command_queue_capabilities_intel */ #define CL_QUEUE_DEFAULT_CAPABILITIES_INTEL 0 #define CL_QUEUE_CAPABILITY_CREATE_SINGLE_QUEUE_EVENTS_INTEL (1 << 0) #define CL_QUEUE_CAPABILITY_CREATE_CROSS_QUEUE_EVENTS_INTEL (1 << 1) #define CL_QUEUE_CAPABILITY_SINGLE_QUEUE_EVENT_WAIT_LIST_INTEL (1 << 2) #define CL_QUEUE_CAPABILITY_CROSS_QUEUE_EVENT_WAIT_LIST_INTEL (1 << 3) #define CL_QUEUE_CAPABILITY_TRANSFER_BUFFER_INTEL (1 << 8) #define CL_QUEUE_CAPABILITY_TRANSFER_BUFFER_RECT_INTEL (1 << 9) #define CL_QUEUE_CAPABILITY_MAP_BUFFER_INTEL (1 << 10) #define CL_QUEUE_CAPABILITY_FILL_BUFFER_INTEL (1 << 11) #define CL_QUEUE_CAPABILITY_TRANSFER_IMAGE_INTEL (1 << 12) #define CL_QUEUE_CAPABILITY_MAP_IMAGE_INTEL (1 << 13) #define CL_QUEUE_CAPABILITY_FILL_IMAGE_INTEL (1 << 14) #define CL_QUEUE_CAPABILITY_TRANSFER_BUFFER_IMAGE_INTEL (1 << 15) #define CL_QUEUE_CAPABILITY_TRANSFER_IMAGE_BUFFER_INTEL (1 << 16) #define CL_QUEUE_CAPABILITY_MARKER_INTEL (1 << 24) #define CL_QUEUE_CAPABILITY_BARRIER_INTEL (1 << 25) #define CL_QUEUE_CAPABILITY_KERNEL_INTEL (1 << 26) /*************************************************************** * cl_intel_queue_no_sync_operations ***************************************************************/ #define cl_intel_queue_no_sync_operations 1 #define CL_INTEL_QUEUE_NO_SYNC_OPERATIONS_EXTENSION_NAME \ "cl_intel_queue_no_sync_operations" /* cl_command_queue_properties */ #define CL_QUEUE_NO_SYNC_OPERATIONS_INTEL (1 << 29) /*************************************************************** * cl_intel_sharing_format_query ***************************************************************/ #define cl_intel_sharing_format_query 1 #define CL_INTEL_SHARING_FORMAT_QUERY_EXTENSION_NAME \ "cl_intel_sharing_format_query" /*************************************************************** * cl_ext_image_requirements_info ***************************************************************/ #if defined(CL_VERSION_3_0) #define cl_ext_image_requirements_info 1 #define CL_EXT_IMAGE_REQUIREMENTS_INFO_EXTENSION_NAME \ "cl_ext_image_requirements_info" /* Types */ typedef cl_uint cl_image_requirements_info_ext; /* cl_image_requirements_info_ext */ #define CL_IMAGE_REQUIREMENTS_BASE_ADDRESS_ALIGNMENT_EXT 0x1292 #define CL_IMAGE_REQUIREMENTS_ROW_PITCH_ALIGNMENT_EXT 0x1290 #define CL_IMAGE_REQUIREMENTS_SIZE_EXT 0x12B2 #define CL_IMAGE_REQUIREMENTS_MAX_WIDTH_EXT 0x12B3 #define CL_IMAGE_REQUIREMENTS_MAX_HEIGHT_EXT 0x12B4 #define CL_IMAGE_REQUIREMENTS_MAX_DEPTH_EXT 0x12B5 #define CL_IMAGE_REQUIREMENTS_MAX_ARRAY_SIZE_EXT 0x12B6 /* Enqueued Commands APIs */ typedef cl_int (CL_API_CALL * clGetImageRequirementsInfoEXT_fn)( cl_context context, const cl_mem_properties* properties, cl_mem_flags flags, const cl_image_format* image_format, const cl_image_desc* image_desc, cl_image_requirements_info_ext param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_3_0; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL clGetImageRequirementsInfoEXT( cl_context context, const cl_mem_properties* properties, cl_mem_flags flags, const cl_image_format* image_format, const cl_image_desc* image_desc, cl_image_requirements_info_ext param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_3_0; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ #endif /* defined(CL_VERSION_3_0) */ /*************************************************************** * cl_ext_image_from_buffer ***************************************************************/ #if defined(CL_VERSION_3_0) #define cl_ext_image_from_buffer 1 #define CL_EXT_IMAGE_FROM_BUFFER_EXTENSION_NAME \ "cl_ext_image_from_buffer" /* cl_image_requirements_info_ext */ #define CL_IMAGE_REQUIREMENTS_SLICE_PITCH_ALIGNMENT_EXT 0x1291 #endif /* defined(CL_VERSION_3_0) */ /*************************************************************** * cl_loader_info ***************************************************************/ #define cl_loader_info 1 #define CL_LOADER_INFO_EXTENSION_NAME \ "cl_loader_info" typedef cl_uint cl_icdl_info; /* cl_icdl_info */ #define CL_ICDL_OCL_VERSION 1 #define CL_ICDL_VERSION 2 #define CL_ICDL_NAME 3 #define CL_ICDL_VENDOR 4 typedef cl_int (CL_API_CALL * clGetICDLoaderInfoOCLICD_fn)( cl_icdl_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret) ; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL clGetICDLoaderInfoOCLICD( cl_icdl_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret) ; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_khr_depth_images ***************************************************************/ #define cl_khr_depth_images 1 #define CL_KHR_DEPTH_IMAGES_EXTENSION_NAME \ "cl_khr_depth_images" #if !defined(CL_VERSION_1_2) /* cl_channel_order - defined in CL.h for OpenCL 1.2 (?) and newer */ #define CL_DEPTH 0x10BD #endif /* !defined(CL_VERSION_1_2) */ /*************************************************************** * cl_ext_float_atomics ***************************************************************/ #define cl_ext_float_atomics 1 #define CL_EXT_FLOAT_ATOMICS_EXTENSION_NAME \ "cl_ext_float_atomics" typedef cl_bitfield cl_device_fp_atomic_capabilities_ext; /* cl_device_fp_atomic_capabilities_ext */ #define CL_DEVICE_GLOBAL_FP_ATOMIC_LOAD_STORE_EXT (1 << 0) #define CL_DEVICE_GLOBAL_FP_ATOMIC_ADD_EXT (1 << 1) #define CL_DEVICE_GLOBAL_FP_ATOMIC_MIN_MAX_EXT (1 << 2) #define CL_DEVICE_LOCAL_FP_ATOMIC_LOAD_STORE_EXT (1 << 16) #define CL_DEVICE_LOCAL_FP_ATOMIC_ADD_EXT (1 << 17) #define CL_DEVICE_LOCAL_FP_ATOMIC_MIN_MAX_EXT (1 << 18) /* cl_device_info */ #define CL_DEVICE_SINGLE_FP_ATOMIC_CAPABILITIES_EXT 0x4231 #define CL_DEVICE_DOUBLE_FP_ATOMIC_CAPABILITIES_EXT 0x4232 #define CL_DEVICE_HALF_FP_ATOMIC_CAPABILITIES_EXT 0x4233 /*************************************************************** * cl_intel_create_mem_object_properties ***************************************************************/ #define cl_intel_create_mem_object_properties 1 #define CL_INTEL_CREATE_MEM_OBJECT_PROPERTIES_EXTENSION_NAME \ "cl_intel_create_mem_object_properties" /* cl_mem_properties */ #define CL_MEM_LOCALLY_UNCACHED_RESOURCE_INTEL 0x4218 #define CL_MEM_DEVICE_ID_INTEL 0x4219 /*************************************************************** * cl_pocl_content_size ***************************************************************/ #define cl_pocl_content_size 1 #define CL_POCL_CONTENT_SIZE_EXTENSION_NAME \ "cl_pocl_content_size" typedef cl_int (CL_API_CALL * clSetContentSizeBufferPoCL_fn)( cl_mem buffer, cl_mem content_size_buffer) CL_API_SUFFIX__VERSION_1_0; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL clSetContentSizeBufferPoCL( cl_mem buffer, cl_mem content_size_buffer) CL_API_SUFFIX__VERSION_1_0; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ #ifdef __cplusplus } #endif #endif /* OPENCL_CL_EXT_H_ */ ocl-icd-2.3.3/khronos-headers/CL/cl_ext_intel.h000066400000000000000000000016061477331540600212620ustar00rootroot00000000000000/******************************************************************************* * Copyright (c) 2008-2020 The Khronos Group Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * ******************************************************************************/ #include #pragma message("The Intel extensions have been moved into cl_ext.h. Please include cl_ext.h directly.") ocl-icd-2.3.3/khronos-headers/CL/cl_gl.h000066400000000000000000000264161477331540600176770ustar00rootroot00000000000000/******************************************************************************* * Copyright (c) 2008-2023 The Khronos Group Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. ******************************************************************************/ #ifndef OPENCL_CL_GL_H_ #define OPENCL_CL_GL_H_ /* ** This header is generated from the Khronos OpenCL XML API Registry. */ #include /* CL_NO_PROTOTYPES implies CL_NO_EXTENSION_PROTOTYPES: */ #if defined(CL_NO_PROTOTYPES) && !defined(CL_NO_EXTENSION_PROTOTYPES) #define CL_NO_EXTENSION_PROTOTYPES #endif /* CL_NO_EXTENSION_PROTOTYPES implies CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES and CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES: */ #if defined(CL_NO_EXTENSION_PROTOTYPES) && \ !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) #define CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES #endif #if defined(CL_NO_EXTENSION_PROTOTYPES) && \ !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) #define CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES #endif #ifdef __cplusplus extern "C" { #endif /*************************************************************** * cl_khr_gl_sharing ***************************************************************/ #define cl_khr_gl_sharing 1 #define CL_KHR_GL_SHARING_EXTENSION_NAME \ "cl_khr_gl_sharing" typedef cl_uint cl_gl_context_info; /* 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 typedef cl_uint cl_gl_object_type; typedef cl_uint cl_gl_texture_info; typedef cl_uint cl_gl_platform_info; /* cl_gl_object_type */ #define CL_GL_OBJECT_BUFFER 0x2000 #define CL_GL_OBJECT_TEXTURE2D 0x2001 #define CL_GL_OBJECT_TEXTURE3D 0x2002 #define CL_GL_OBJECT_RENDERBUFFER 0x2003 #if defined(CL_VERSION_1_2) /* cl_gl_object_type */ #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 #endif /* defined(CL_VERSION_1_2) */ /* cl_gl_texture_info */ #define CL_GL_TEXTURE_TARGET 0x2004 #define CL_GL_MIPMAP_LEVEL 0x2005 typedef 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) CL_API_SUFFIX__VERSION_1_0; typedef cl_mem (CL_API_CALL * clCreateFromGLBuffer_fn)( cl_context context, cl_mem_flags flags, cl_GLuint bufobj, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0; #if !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) 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; extern CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLBuffer( cl_context context, cl_mem_flags flags, cl_GLuint bufobj, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0; #endif /* !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ #if defined(CL_VERSION_1_2) typedef cl_mem (CL_API_CALL * clCreateFromGLTexture_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_2; #if !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) 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; #endif /* !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ #endif /* defined(CL_VERSION_1_2) */ 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_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; #if !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) 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; #endif /* !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /* OpenCL 1.0 APIs that were deprecated in OpenCL 1.2 */ 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_1_DEPRECATED; 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_1_DEPRECATED; #if !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY 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_API_SUFFIX__VERSION_1_1_DEPRECATED; extern CL_API_ENTRY 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_API_SUFFIX__VERSION_1_1_DEPRECATED; #endif /* !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_khr_gl_event ***************************************************************/ #define cl_khr_gl_event 1 #define CL_KHR_GL_EVENT_EXTENSION_NAME \ "cl_khr_gl_event" typedef struct __GLsync * cl_GLsync; /* cl_command_type */ #define CL_COMMAND_GL_FENCE_SYNC_OBJECT_KHR 0x200D typedef cl_event (CL_API_CALL * clCreateEventFromGLsyncKHR_fn)( cl_context context, cl_GLsync sync, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_1; #if !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_event CL_API_CALL clCreateEventFromGLsyncKHR( cl_context context, cl_GLsync sync, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_1; #endif /* !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_khr_gl_depth_images ***************************************************************/ #define cl_khr_gl_depth_images 1 #define CL_KHR_GL_DEPTH_IMAGES_EXTENSION_NAME \ "cl_khr_gl_depth_images" #if !defined(CL_VERSION_1_2) /* cl_channel_order - defined in CL.h for OpenCL 1.2 and newer */ #define CL_DEPTH_STENCIL 0x10BE #endif /* !defined(CL_VERSION_1_2) */ #if !defined(CL_VERSION_1_2) /* cl_channel_type - defined in CL.h for OpenCL 1.2 and newer */ #define CL_UNORM_INT24 0x10DF #endif /* !defined(CL_VERSION_1_2) */ /*************************************************************** * cl_khr_gl_msaa_sharing ***************************************************************/ #define cl_khr_gl_msaa_sharing 1 #define CL_KHR_GL_MSAA_SHARING_EXTENSION_NAME \ "cl_khr_gl_msaa_sharing" /* cl_gl_texture_info */ #define CL_GL_NUM_SAMPLES 0x2012 /*************************************************************** * cl_intel_sharing_format_query_gl ***************************************************************/ #define cl_intel_sharing_format_query_gl 1 #define CL_INTEL_SHARING_FORMAT_QUERY_GL_EXTENSION_NAME \ "cl_intel_sharing_format_query_gl" /* when cl_khr_gl_sharing is supported */ typedef cl_int (CL_API_CALL * clGetSupportedGLTextureFormatsINTEL_fn)( cl_context context, cl_mem_flags flags, cl_mem_object_type image_type, cl_uint num_entries, cl_GLenum* gl_formats, cl_uint* num_texture_formats) ; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL clGetSupportedGLTextureFormatsINTEL( cl_context context, cl_mem_flags flags, cl_mem_object_type image_type, cl_uint num_entries, cl_GLenum* gl_formats, cl_uint* num_texture_formats) ; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ #ifdef __cplusplus } #endif #endif /* OPENCL_CL_GL_H_ */ ocl-icd-2.3.3/khronos-headers/CL/cl_gl_ext.h000066400000000000000000000016111477331540600205450ustar00rootroot00000000000000/******************************************************************************* * Copyright (c) 2008-2021 The Khronos Group Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. ******************************************************************************/ #include #pragma message("The extensions in cl_gl_ext.h have been moved into cl_gl.h. Please include cl_gl.h directly.") ocl-icd-2.3.3/khronos-headers/CL/cl_half.h000066400000000000000000000242761477331540600202110ustar00rootroot00000000000000/******************************************************************************* * Copyright (c) 2019-2020 The Khronos Group Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. ******************************************************************************/ /** * This is a header-only utility library that provides OpenCL host code with * routines for converting to/from cl_half values. * * Example usage: * * #include * ... * cl_half h = cl_half_from_float(0.5f, CL_HALF_RTE); * cl_float f = cl_half_to_float(h); */ #ifndef OPENCL_CL_HALF_H #define OPENCL_CL_HALF_H #include #include #ifdef __cplusplus extern "C" { #endif /** * Rounding mode used when converting to cl_half. */ typedef enum { CL_HALF_RTE, // round to nearest even CL_HALF_RTZ, // round towards zero CL_HALF_RTP, // round towards positive infinity CL_HALF_RTN, // round towards negative infinity } cl_half_rounding_mode; /* Private utility macros. */ #define CL_HALF_EXP_MASK 0x7C00 #define CL_HALF_MAX_FINITE_MAG 0x7BFF /* * Utility to deal with values that overflow when converting to half precision. */ static inline cl_half cl_half_handle_overflow(cl_half_rounding_mode rounding_mode, uint16_t sign) { if (rounding_mode == CL_HALF_RTZ) { // Round overflow towards zero -> largest finite number (preserving sign) return (sign << 15) | CL_HALF_MAX_FINITE_MAG; } else if (rounding_mode == CL_HALF_RTP && sign) { // Round negative overflow towards positive infinity -> most negative finite number return (1 << 15) | CL_HALF_MAX_FINITE_MAG; } else if (rounding_mode == CL_HALF_RTN && !sign) { // Round positive overflow towards negative infinity -> largest finite number return CL_HALF_MAX_FINITE_MAG; } // Overflow to infinity return (sign << 15) | CL_HALF_EXP_MASK; } /* * Utility to deal with values that underflow when converting to half precision. */ static inline cl_half cl_half_handle_underflow(cl_half_rounding_mode rounding_mode, uint16_t sign) { if (rounding_mode == CL_HALF_RTP && !sign) { // Round underflow towards positive infinity -> smallest positive value return (sign << 15) | 1; } else if (rounding_mode == CL_HALF_RTN && sign) { // Round underflow towards negative infinity -> largest negative value return (sign << 15) | 1; } // Flush to zero return (sign << 15); } /** * Convert a cl_float to a cl_half. */ static inline cl_half cl_half_from_float(cl_float f, cl_half_rounding_mode rounding_mode) { // Type-punning to get direct access to underlying bits union { cl_float f; uint32_t i; } f32; f32.f = f; // Extract sign bit uint16_t sign = f32.i >> 31; // Extract FP32 exponent and mantissa uint32_t f_exp = (f32.i >> (CL_FLT_MANT_DIG - 1)) & 0xFF; uint32_t f_mant = f32.i & ((1 << (CL_FLT_MANT_DIG - 1)) - 1); // Remove FP32 exponent bias int32_t exp = f_exp - CL_FLT_MAX_EXP + 1; // Add FP16 exponent bias uint16_t h_exp = (uint16_t)(exp + CL_HALF_MAX_EXP - 1); // Position of the bit that will become the FP16 mantissa LSB uint32_t lsb_pos = CL_FLT_MANT_DIG - CL_HALF_MANT_DIG; // Check for NaN / infinity if (f_exp == 0xFF) { if (f_mant) { // NaN -> propagate mantissa and silence it uint16_t h_mant = (uint16_t)(f_mant >> lsb_pos); h_mant |= 0x200; return (sign << 15) | CL_HALF_EXP_MASK | h_mant; } else { // Infinity -> zero mantissa return (sign << 15) | CL_HALF_EXP_MASK; } } // Check for zero if (!f_exp && !f_mant) { return (sign << 15); } // Check for overflow if (exp >= CL_HALF_MAX_EXP) { return cl_half_handle_overflow(rounding_mode, sign); } // Check for underflow if (exp < (CL_HALF_MIN_EXP - CL_HALF_MANT_DIG - 1)) { return cl_half_handle_underflow(rounding_mode, sign); } // Check for value that will become denormal if (exp < -14) { // Denormal -> include the implicit 1 from the FP32 mantissa h_exp = 0; f_mant |= 1 << (CL_FLT_MANT_DIG - 1); // Mantissa shift amount depends on exponent lsb_pos = -exp + (CL_FLT_MANT_DIG - 25); } // Generate FP16 mantissa by shifting FP32 mantissa uint16_t h_mant = (uint16_t)(f_mant >> lsb_pos); // Check whether we need to round uint32_t halfway = 1 << (lsb_pos - 1); uint32_t mask = (halfway << 1) - 1; switch (rounding_mode) { case CL_HALF_RTE: if ((f_mant & mask) > halfway) { // More than halfway -> round up h_mant += 1; } else if ((f_mant & mask) == halfway) { // Exactly halfway -> round to nearest even if (h_mant & 0x1) h_mant += 1; } break; case CL_HALF_RTZ: // Mantissa has already been truncated -> do nothing break; case CL_HALF_RTP: if ((f_mant & mask) && !sign) { // Round positive numbers up h_mant += 1; } break; case CL_HALF_RTN: if ((f_mant & mask) && sign) { // Round negative numbers down h_mant += 1; } break; } // Check for mantissa overflow if (h_mant & 0x400) { h_exp += 1; h_mant = 0; } return (sign << 15) | (h_exp << 10) | h_mant; } /** * Convert a cl_double to a cl_half. */ static inline cl_half cl_half_from_double(cl_double d, cl_half_rounding_mode rounding_mode) { // Type-punning to get direct access to underlying bits union { cl_double d; uint64_t i; } f64; f64.d = d; // Extract sign bit uint16_t sign = f64.i >> 63; // Extract FP64 exponent and mantissa uint64_t d_exp = (f64.i >> (CL_DBL_MANT_DIG - 1)) & 0x7FF; uint64_t d_mant = f64.i & (((uint64_t)1 << (CL_DBL_MANT_DIG - 1)) - 1); // Remove FP64 exponent bias int64_t exp = d_exp - CL_DBL_MAX_EXP + 1; // Add FP16 exponent bias uint16_t h_exp = (uint16_t)(exp + CL_HALF_MAX_EXP - 1); // Position of the bit that will become the FP16 mantissa LSB uint32_t lsb_pos = CL_DBL_MANT_DIG - CL_HALF_MANT_DIG; // Check for NaN / infinity if (d_exp == 0x7FF) { if (d_mant) { // NaN -> propagate mantissa and silence it uint16_t h_mant = (uint16_t)(d_mant >> lsb_pos); h_mant |= 0x200; return (sign << 15) | CL_HALF_EXP_MASK | h_mant; } else { // Infinity -> zero mantissa return (sign << 15) | CL_HALF_EXP_MASK; } } // Check for zero if (!d_exp && !d_mant) { return (sign << 15); } // Check for overflow if (exp >= CL_HALF_MAX_EXP) { return cl_half_handle_overflow(rounding_mode, sign); } // Check for underflow if (exp < (CL_HALF_MIN_EXP - CL_HALF_MANT_DIG - 1)) { return cl_half_handle_underflow(rounding_mode, sign); } // Check for value that will become denormal if (exp < -14) { // Include the implicit 1 from the FP64 mantissa h_exp = 0; d_mant |= (uint64_t)1 << (CL_DBL_MANT_DIG - 1); // Mantissa shift amount depends on exponent lsb_pos = (uint32_t)(-exp + (CL_DBL_MANT_DIG - 25)); } // Generate FP16 mantissa by shifting FP64 mantissa uint16_t h_mant = (uint16_t)(d_mant >> lsb_pos); // Check whether we need to round uint64_t halfway = (uint64_t)1 << (lsb_pos - 1); uint64_t mask = (halfway << 1) - 1; switch (rounding_mode) { case CL_HALF_RTE: if ((d_mant & mask) > halfway) { // More than halfway -> round up h_mant += 1; } else if ((d_mant & mask) == halfway) { // Exactly halfway -> round to nearest even if (h_mant & 0x1) h_mant += 1; } break; case CL_HALF_RTZ: // Mantissa has already been truncated -> do nothing break; case CL_HALF_RTP: if ((d_mant & mask) && !sign) { // Round positive numbers up h_mant += 1; } break; case CL_HALF_RTN: if ((d_mant & mask) && sign) { // Round negative numbers down h_mant += 1; } break; } // Check for mantissa overflow if (h_mant & 0x400) { h_exp += 1; h_mant = 0; } return (sign << 15) | (h_exp << 10) | h_mant; } /** * Convert a cl_half to a cl_float. */ static inline cl_float cl_half_to_float(cl_half h) { // Type-punning to get direct access to underlying bits union { cl_float f; uint32_t i; } f32; // Extract sign bit uint16_t sign = h >> 15; // Extract FP16 exponent and mantissa uint16_t h_exp = (h >> (CL_HALF_MANT_DIG - 1)) & 0x1F; uint16_t h_mant = h & 0x3FF; // Remove FP16 exponent bias int32_t exp = h_exp - CL_HALF_MAX_EXP + 1; // Add FP32 exponent bias uint32_t f_exp = exp + CL_FLT_MAX_EXP - 1; // Check for NaN / infinity if (h_exp == 0x1F) { if (h_mant) { // NaN -> propagate mantissa and silence it uint32_t f_mant = h_mant << (CL_FLT_MANT_DIG - CL_HALF_MANT_DIG); f_mant |= 0x400000; f32.i = (sign << 31) | 0x7F800000 | f_mant; return f32.f; } else { // Infinity -> zero mantissa f32.i = (sign << 31) | 0x7F800000; return f32.f; } } // Check for zero / denormal if (h_exp == 0) { if (h_mant == 0) { // Zero -> zero exponent f_exp = 0; } else { // Denormal -> normalize it // - Shift mantissa to make most-significant 1 implicit // - Adjust exponent accordingly uint32_t shift = 0; while ((h_mant & 0x400) == 0) { h_mant <<= 1; shift++; } h_mant &= 0x3FF; f_exp -= shift - 1; } } f32.i = (sign << 31) | (f_exp << 23) | (h_mant << 13); return f32.f; } #undef CL_HALF_EXP_MASK #undef CL_HALF_MAX_FINITE_MAG #ifdef __cplusplus } #endif #endif /* OPENCL_CL_HALF_H */ ocl-icd-2.3.3/khronos-headers/CL/cl_icd.h000066400000000000000000001460661477331540600200400ustar00rootroot00000000000000/******************************************************************************* * Copyright (c) 2019-2020 The Khronos Group Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. ******************************************************************************/ #ifndef OPENCL_CL_ICD_H #define OPENCL_CL_ICD_H #include #include #include #include #if defined(_WIN32) #include #include #include #endif #ifdef __cplusplus extern "C" { #endif /* * This file contains pointer type definitions for each of the CL API calls as * well as a type definition for the dispatch table used by the Khronos ICD * loader (see cl_khr_icd extension specification for background). */ /* API function pointer definitions */ // Platform APIs typedef cl_int(CL_API_CALL *cl_api_clGetPlatformIDs)( cl_uint num_entries, cl_platform_id *platforms, cl_uint *num_platforms) CL_API_SUFFIX__VERSION_1_0; typedef cl_int(CL_API_CALL *cl_api_clGetPlatformInfo)( 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; // Device APIs typedef cl_int(CL_API_CALL *cl_api_clGetDeviceIDs)( 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 *cl_api_clGetDeviceInfo)( 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; #ifdef CL_VERSION_1_2 typedef cl_int(CL_API_CALL *cl_api_clCreateSubDevices)( cl_device_id in_device, const cl_device_partition_property *partition_properties, cl_uint num_entries, cl_device_id *out_devices, cl_uint *num_devices); typedef cl_int(CL_API_CALL *cl_api_clRetainDevice)( cl_device_id device) CL_API_SUFFIX__VERSION_1_2; typedef cl_int(CL_API_CALL *cl_api_clReleaseDevice)( cl_device_id device) CL_API_SUFFIX__VERSION_1_2; #else typedef void *cl_api_clCreateSubDevices; typedef void *cl_api_clRetainDevice; typedef void *cl_api_clReleaseDevice; #endif // Context APIs typedef cl_context(CL_API_CALL *cl_api_clCreateContext)( 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 *cl_api_clCreateContextFromType)( 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 *cl_api_clRetainContext)( cl_context context) CL_API_SUFFIX__VERSION_1_0; typedef cl_int(CL_API_CALL *cl_api_clReleaseContext)( cl_context context) CL_API_SUFFIX__VERSION_1_0; typedef cl_int(CL_API_CALL *cl_api_clGetContextInfo)( 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; // Command Queue APIs typedef cl_command_queue(CL_API_CALL *cl_api_clCreateCommandQueue)( cl_context context, cl_device_id device, cl_command_queue_properties properties, cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_0; #ifdef CL_VERSION_2_0 typedef cl_command_queue(CL_API_CALL *cl_api_clCreateCommandQueueWithProperties)( cl_context /* context */, cl_device_id /* device */, const cl_queue_properties * /* properties */, cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_2_0; #else typedef void *cl_api_clCreateCommandQueueWithProperties; #endif typedef cl_int(CL_API_CALL *cl_api_clRetainCommandQueue)( cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0; typedef cl_int(CL_API_CALL *cl_api_clReleaseCommandQueue)( cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0; typedef cl_int(CL_API_CALL *cl_api_clGetCommandQueueInfo)( 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; // Memory Object APIs typedef cl_mem(CL_API_CALL *cl_api_clCreateBuffer)( cl_context context, cl_mem_flags flags, size_t size, void *host_ptr, cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_0; #ifdef CL_VERSION_1_2 typedef cl_mem(CL_API_CALL *cl_api_clCreateImage)( 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; #else typedef void *cl_api_clCreateImage; #endif #ifdef CL_VERSION_3_0 typedef cl_mem(CL_API_CALL *cl_api_clCreateBufferWithProperties)( cl_context context, const cl_mem_properties *properties, cl_mem_flags flags, size_t size, void *host_ptr, cl_int *errcode_ret) CL_API_SUFFIX__VERSION_3_0; typedef cl_mem(CL_API_CALL *cl_api_clCreateImageWithProperties)( cl_context context, const cl_mem_properties *properties, 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_3_0; typedef cl_int(CL_API_CALL* cl_api_clSetContextDestructorCallback)( cl_context context, void(CL_CALLBACK* pfn_notify)(cl_context context, void* user_data), void* user_data) CL_API_SUFFIX__VERSION_3_0; #else typedef void *cl_api_clCreateBufferWithProperties; typedef void *cl_api_clCreateImageWithProperties; typedef void *cl_api_clSetContextDestructorCallback; #endif typedef cl_int(CL_API_CALL *cl_api_clRetainMemObject)( cl_mem memobj) CL_API_SUFFIX__VERSION_1_0; typedef cl_int(CL_API_CALL *cl_api_clReleaseMemObject)( cl_mem memobj) CL_API_SUFFIX__VERSION_1_0; typedef cl_int(CL_API_CALL *cl_api_clGetSupportedImageFormats)( 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 *cl_api_clGetMemObjectInfo)( 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 *cl_api_clGetImageInfo)( 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; #ifdef CL_VERSION_2_0 typedef cl_mem(CL_API_CALL *cl_api_clCreatePipe)( 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 *cl_api_clGetPipeInfo)( 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 void *(CL_API_CALL *cl_api_clSVMAlloc)( cl_context /* context */, cl_svm_mem_flags /* flags */, size_t /* size */, unsigned int /* alignment */)CL_API_SUFFIX__VERSION_2_0; typedef void(CL_API_CALL *cl_api_clSVMFree)( cl_context /* context */, void * /* svm_pointer */) CL_API_SUFFIX__VERSION_2_0; #else typedef void *cl_api_clCreatePipe; typedef void *cl_api_clGetPipeInfo; typedef void *cl_api_clSVMAlloc; typedef void *cl_api_clSVMFree; #endif // Sampler APIs typedef cl_sampler(CL_API_CALL *cl_api_clCreateSampler)( 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 *cl_api_clRetainSampler)( cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0; typedef cl_int(CL_API_CALL *cl_api_clReleaseSampler)( cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0; typedef cl_int(CL_API_CALL *cl_api_clGetSamplerInfo)( 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; #ifdef CL_VERSION_2_0 typedef cl_sampler(CL_API_CALL *cl_api_clCreateSamplerWithProperties)( cl_context /* context */, const cl_sampler_properties * /* sampler_properties */, cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_2_0; #else typedef void *cl_api_clCreateSamplerWithProperties; #endif // Program Object APIs typedef cl_program(CL_API_CALL *cl_api_clCreateProgramWithSource)( cl_context context, cl_uint count, const char **strings, const size_t *lengths, cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_0; typedef cl_program(CL_API_CALL *cl_api_clCreateProgramWithBinary)( 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; #ifdef CL_VERSION_1_2 typedef cl_program(CL_API_CALL *cl_api_clCreateProgramWithBuiltInKernels)( 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; #else typedef void *cl_api_clCreateProgramWithBuiltInKernels; #endif typedef cl_int(CL_API_CALL *cl_api_clRetainProgram)( cl_program program) CL_API_SUFFIX__VERSION_1_0; typedef cl_int(CL_API_CALL *cl_api_clReleaseProgram)( cl_program program) CL_API_SUFFIX__VERSION_1_0; typedef cl_int(CL_API_CALL *cl_api_clBuildProgram)( 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; #ifdef CL_VERSION_1_2 typedef cl_int(CL_API_CALL *cl_api_clCompileProgram)( 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 *cl_api_clLinkProgram)( 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; #else typedef void *cl_api_clCompileProgram; typedef void *cl_api_clLinkProgram; #endif #ifdef CL_VERSION_2_2 typedef cl_int(CL_API_CALL *cl_api_clSetProgramSpecializationConstant)( 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 *cl_api_clSetProgramReleaseCallback)( cl_program program, void(CL_CALLBACK *pfn_notify)(cl_program program, void *user_data), void *user_data) CL_API_SUFFIX__VERSION_2_2; #else typedef void *cl_api_clSetProgramSpecializationConstant; typedef void *cl_api_clSetProgramReleaseCallback; #endif #ifdef CL_VERSION_1_2 typedef cl_int(CL_API_CALL *cl_api_clUnloadPlatformCompiler)( cl_platform_id platform) CL_API_SUFFIX__VERSION_1_2; #else typedef void *cl_api_clUnloadPlatformCompiler; #endif typedef cl_int(CL_API_CALL *cl_api_clGetProgramInfo)( 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 *cl_api_clGetProgramBuildInfo)( 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 *cl_api_clCreateKernel)( cl_program program, const char *kernel_name, cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_0; typedef cl_int(CL_API_CALL *cl_api_clCreateKernelsInProgram)( 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 *cl_api_clRetainKernel)( cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0; typedef cl_int(CL_API_CALL *cl_api_clReleaseKernel)( cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0; typedef cl_int(CL_API_CALL *cl_api_clSetKernelArg)( 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 *cl_api_clGetKernelInfo)( 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; #ifdef CL_VERSION_1_2 typedef cl_int(CL_API_CALL *cl_api_clGetKernelArgInfo)( 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; #else typedef void *cl_api_clGetKernelArgInfo; #endif typedef cl_int(CL_API_CALL *cl_api_clGetKernelWorkGroupInfo)( 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; #ifdef CL_VERSION_2_0 typedef cl_int(CL_API_CALL *cl_api_clSetKernelArgSVMPointer)( cl_kernel /* kernel */, cl_uint /* arg_index */, const void * /* arg_value */) CL_API_SUFFIX__VERSION_2_0; typedef cl_int(CL_API_CALL *cl_api_clSetKernelExecInfo)( 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 *cl_api_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_API_SUFFIX__VERSION_2_0; #else typedef void *cl_api_clSetKernelArgSVMPointer; typedef void *cl_api_clSetKernelExecInfo; typedef void *cl_api_clGetKernelSubGroupInfoKHR; #endif // Event Object APIs typedef cl_int(CL_API_CALL *cl_api_clWaitForEvents)( cl_uint num_events, const cl_event *event_list) CL_API_SUFFIX__VERSION_1_0; typedef cl_int(CL_API_CALL *cl_api_clGetEventInfo)( 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_int(CL_API_CALL *cl_api_clRetainEvent)(cl_event event) CL_API_SUFFIX__VERSION_1_0; typedef cl_int(CL_API_CALL *cl_api_clReleaseEvent)(cl_event event) CL_API_SUFFIX__VERSION_1_0; // Profiling APIs typedef cl_int(CL_API_CALL *cl_api_clGetEventProfilingInfo)( 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 *cl_api_clFlush)( cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0; typedef cl_int(CL_API_CALL *cl_api_clFinish)( cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0; // Enqueued Commands APIs typedef cl_int(CL_API_CALL *cl_api_clEnqueueReadBuffer)( 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; #ifdef CL_VERSION_1_1 typedef cl_int(CL_API_CALL *cl_api_clEnqueueReadBufferRect)( cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_read, const size_t *buffer_origin, const size_t *host_origin, 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; #else typedef void *cl_api_clEnqueueReadBufferRect; #endif typedef cl_int(CL_API_CALL *cl_api_clEnqueueWriteBuffer)( 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; #ifdef CL_VERSION_1_1 typedef cl_int(CL_API_CALL *cl_api_clEnqueueWriteBufferRect)( cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_read, const size_t *buffer_origin, const size_t *host_origin, 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; #else typedef void *cl_api_clEnqueueWriteBufferRect; #endif #ifdef CL_VERSION_1_2 typedef cl_int(CL_API_CALL *cl_api_clEnqueueFillBuffer)( cl_command_queue command_queue, cl_mem buffer, const void *pattern, size_t pattern_size, size_t 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_2; #else typedef void *cl_api_clEnqueueFillBuffer; #endif typedef cl_int(CL_API_CALL *cl_api_clEnqueueCopyBuffer)( 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; #ifdef CL_VERSION_1_1 typedef cl_int(CL_API_CALL *cl_api_clEnqueueCopyBufferRect)( 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; #else typedef void *cl_api_clEnqueueCopyBufferRect; #endif typedef cl_int(CL_API_CALL *cl_api_clEnqueueReadImage)( cl_command_queue command_queue, cl_mem image, cl_bool blocking_read, const size_t *origin, const size_t *region, 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 *cl_api_clEnqueueWriteImage)( cl_command_queue command_queue, cl_mem image, cl_bool blocking_write, const size_t *origin, const size_t *region, 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; #ifdef CL_VERSION_1_2 typedef cl_int(CL_API_CALL *cl_api_clEnqueueFillImage)( cl_command_queue command_queue, cl_mem image, const void *fill_color, const size_t 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_2; #else typedef void *cl_api_clEnqueueFillImage; #endif typedef cl_int(CL_API_CALL *cl_api_clEnqueueCopyImage)( cl_command_queue command_queue, cl_mem src_image, cl_mem dst_image, const size_t *src_origin, const size_t *dst_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_0; typedef cl_int(CL_API_CALL *cl_api_clEnqueueCopyImageToBuffer)( cl_command_queue command_queue, cl_mem src_image, cl_mem dst_buffer, const size_t *src_origin, const size_t *region, 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 *cl_api_clEnqueueCopyBufferToImage)( cl_command_queue command_queue, cl_mem src_buffer, cl_mem dst_image, size_t src_offset, const size_t *dst_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_0; typedef void *(CL_API_CALL *cl_api_clEnqueueMapBuffer)( 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 *cl_api_clEnqueueMapImage)( cl_command_queue command_queue, cl_mem image, cl_bool blocking_map, cl_map_flags map_flags, const size_t *origin, const size_t *region, 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 *cl_api_clEnqueueUnmapMemObject)( 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; #ifdef CL_VERSION_1_2 typedef cl_int(CL_API_CALL *cl_api_clEnqueueMigrateMemObjects)( 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; #else typedef void *cl_api_clEnqueueMigrateMemObjects; #endif typedef cl_int(CL_API_CALL *cl_api_clEnqueueNDRangeKernel)( 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 *cl_api_clEnqueueTask)( 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 *cl_api_clEnqueueNativeKernel)( 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; #ifdef CL_VERSION_1_2 typedef cl_int(CL_API_CALL *cl_api_clEnqueueMarkerWithWaitList)( 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 *cl_api_clEnqueueBarrierWithWaitList)( 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 *cl_api_clGetExtensionFunctionAddressForPlatform)( cl_platform_id platform, const char *function_name)CL_API_SUFFIX__VERSION_1_2; #else typedef void *cl_api_clEnqueueMarkerWithWaitList; typedef void *cl_api_clEnqueueBarrierWithWaitList; typedef void *cl_api_clGetExtensionFunctionAddressForPlatform; #endif // Shared Virtual Memory APIs #ifdef CL_VERSION_2_0 typedef cl_int(CL_API_CALL *cl_api_clEnqueueSVMFree)( 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 *cl_api_clEnqueueSVMMemcpy)( 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 *cl_api_clEnqueueSVMMemFill)( 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 *cl_api_clEnqueueSVMMap)( cl_command_queue /* command_queue */, cl_bool /* blocking_map */, cl_map_flags /* map_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 *cl_api_clEnqueueSVMUnmap)( 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; #else typedef void *cl_api_clEnqueueSVMFree; typedef void *cl_api_clEnqueueSVMMemcpy; typedef void *cl_api_clEnqueueSVMMemFill; typedef void *cl_api_clEnqueueSVMMap; typedef void *cl_api_clEnqueueSVMUnmap; #endif // Deprecated APIs typedef cl_int(CL_API_CALL *cl_api_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_DEPRECATED; typedef cl_mem(CL_API_CALL *cl_api_clCreateImage2D)( 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_1_DEPRECATED; typedef cl_mem(CL_API_CALL *cl_api_clCreateImage3D)( 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_1_DEPRECATED; typedef cl_int(CL_API_CALL *cl_api_clUnloadCompiler)(void) CL_API_SUFFIX__VERSION_1_1_DEPRECATED; typedef cl_int(CL_API_CALL *cl_api_clEnqueueMarker)( cl_command_queue command_queue, cl_event *event) CL_API_SUFFIX__VERSION_1_1_DEPRECATED; typedef cl_int(CL_API_CALL *cl_api_clEnqueueWaitForEvents)( cl_command_queue command_queue, cl_uint num_events, const cl_event *event_list) CL_API_SUFFIX__VERSION_1_1_DEPRECATED; typedef cl_int(CL_API_CALL *cl_api_clEnqueueBarrier)( cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_1_DEPRECATED; typedef void *(CL_API_CALL *cl_api_clGetExtensionFunctionAddress)( const char *function_name)CL_API_SUFFIX__VERSION_1_1_DEPRECATED; // GL and other APIs typedef cl_mem(CL_API_CALL *cl_api_clCreateFromGLBuffer)( 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 *cl_api_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; typedef cl_mem(CL_API_CALL *cl_api_clCreateFromGLTexture2D)( 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 *cl_api_clCreateFromGLTexture3D)( 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 *cl_api_clCreateFromGLRenderbuffer)( 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 *cl_api_clGetGLObjectInfo)( 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 *cl_api_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; typedef cl_int(CL_API_CALL *cl_api_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; typedef cl_int(CL_API_CALL *cl_api_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; /* cl_khr_gl_sharing */ typedef cl_int(CL_API_CALL *cl_api_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_khr_gl_event */ typedef cl_event(CL_API_CALL *cl_api_clCreateEventFromGLsyncKHR)( cl_context context, cl_GLsync sync, cl_int *errcode_ret); #if defined(_WIN32) /* cl_khr_d3d10_sharing */ typedef cl_int(CL_API_CALL *cl_api_clGetDeviceIDsFromD3D10KHR)( cl_platform_id platform, cl_d3d10_device_source_khr d3d_device_source, void *d3d_object, cl_d3d10_device_set_khr d3d_device_set, cl_uint num_entries, cl_device_id *devices, cl_uint *num_devices) CL_API_SUFFIX__VERSION_1_0; typedef cl_mem(CL_API_CALL *cl_api_clCreateFromD3D10BufferKHR)( cl_context context, cl_mem_flags flags, ID3D10Buffer *resource, cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_0; typedef cl_mem(CL_API_CALL *cl_api_clCreateFromD3D10Texture2DKHR)( cl_context context, cl_mem_flags flags, ID3D10Texture2D *resource, UINT subresource, cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_0; typedef cl_mem(CL_API_CALL *cl_api_clCreateFromD3D10Texture3DKHR)( cl_context context, cl_mem_flags flags, ID3D10Texture3D *resource, UINT subresource, cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_0; typedef cl_int(CL_API_CALL *cl_api_clEnqueueAcquireD3D10ObjectsKHR)( 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 *cl_api_clEnqueueReleaseD3D10ObjectsKHR)( 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 clGetDeviceIDsFromD3D10KHR( cl_platform_id platform, cl_d3d10_device_source_khr d3d_device_source, void *d3d_object, cl_d3d10_device_set_khr d3d_device_set, cl_uint num_entries, cl_device_id *devices, cl_uint *num_devices); extern CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10BufferKHR(cl_context context, cl_mem_flags flags, ID3D10Buffer *resource, cl_int *errcode_ret); extern CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture2DKHR( cl_context context, cl_mem_flags flags, ID3D10Texture2D *resource, UINT subresource, cl_int *errcode_ret); extern CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture3DKHR( cl_context context, cl_mem_flags flags, ID3D10Texture3D *resource, UINT subresource, cl_int *errcode_ret); extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D10ObjectsKHR( 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 clEnqueueReleaseD3D10ObjectsKHR( 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_khr_d3d11_sharing */ typedef cl_int(CL_API_CALL *cl_api_clGetDeviceIDsFromD3D11KHR)( cl_platform_id platform, cl_d3d11_device_source_khr d3d_device_source, void *d3d_object, cl_d3d11_device_set_khr d3d_device_set, cl_uint num_entries, cl_device_id *devices, cl_uint *num_devices) CL_API_SUFFIX__VERSION_1_2; typedef cl_mem(CL_API_CALL *cl_api_clCreateFromD3D11BufferKHR)( cl_context context, cl_mem_flags flags, ID3D11Buffer *resource, cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_2; typedef cl_mem(CL_API_CALL *cl_api_clCreateFromD3D11Texture2DKHR)( cl_context context, cl_mem_flags flags, ID3D11Texture2D *resource, UINT subresource, cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_2; typedef cl_mem(CL_API_CALL *cl_api_clCreateFromD3D11Texture3DKHR)( cl_context context, cl_mem_flags flags, ID3D11Texture3D *resource, UINT subresource, cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_2; typedef cl_int(CL_API_CALL *cl_api_clEnqueueAcquireD3D11ObjectsKHR)( 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_2; typedef cl_int(CL_API_CALL *cl_api_clEnqueueReleaseD3D11ObjectsKHR)( 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_2; /* cl_khr_dx9_media_sharing */ typedef cl_int(CL_API_CALL *cl_api_clGetDeviceIDsFromDX9MediaAdapterKHR)( cl_platform_id platform, cl_uint num_media_adapters, cl_dx9_media_adapter_type_khr *media_adapters_type, void *media_adapters, cl_dx9_media_adapter_set_khr media_adapter_set, cl_uint num_entries, cl_device_id *devices, cl_uint *num_devices) CL_API_SUFFIX__VERSION_1_2; typedef cl_mem(CL_API_CALL *cl_api_clCreateFromDX9MediaSurfaceKHR)( cl_context context, cl_mem_flags flags, cl_dx9_media_adapter_type_khr adapter_type, void *surface_info, cl_uint plane, cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_2; typedef cl_int(CL_API_CALL *cl_api_clEnqueueAcquireDX9MediaSurfacesKHR)( 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_2; typedef cl_int(CL_API_CALL *cl_api_clEnqueueReleaseDX9MediaSurfacesKHR)( 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_2; /* cl_khr_d3d11_sharing */ extern CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromD3D11KHR( cl_platform_id platform, cl_d3d11_device_source_khr d3d_device_source, void *d3d_object, cl_d3d11_device_set_khr d3d_device_set, cl_uint num_entries, cl_device_id *devices, cl_uint *num_devices); extern CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11BufferKHR(cl_context context, cl_mem_flags flags, ID3D11Buffer *resource, cl_int *errcode_ret); extern CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture2DKHR( cl_context context, cl_mem_flags flags, ID3D11Texture2D *resource, UINT subresource, cl_int *errcode_ret); extern CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture3DKHR( cl_context context, cl_mem_flags flags, ID3D11Texture3D *resource, UINT subresource, cl_int *errcode_ret); extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D11ObjectsKHR( 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 clEnqueueReleaseD3D11ObjectsKHR( 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_khr_dx9_media_sharing */ extern CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromDX9MediaAdapterKHR( cl_platform_id platform, cl_uint num_media_adapters, cl_dx9_media_adapter_type_khr *media_adapter_type, void *media_adapters, cl_dx9_media_adapter_set_khr media_adapter_set, cl_uint num_entries, cl_device_id *devices, cl_uint *num_devices); extern CL_API_ENTRY cl_mem CL_API_CALL clCreateFromDX9MediaSurfaceKHR( cl_context context, cl_mem_flags flags, cl_dx9_media_adapter_type_khr adapter_type, void *surface_info, cl_uint plane, cl_int *errcode_ret); extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireDX9MediaSurfacesKHR( 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 clEnqueueReleaseDX9MediaSurfacesKHR( 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); #else /* cl_khr_d3d10_sharing */ typedef void *cl_api_clGetDeviceIDsFromD3D10KHR; typedef void *cl_api_clCreateFromD3D10BufferKHR; typedef void *cl_api_clCreateFromD3D10Texture2DKHR; typedef void *cl_api_clCreateFromD3D10Texture3DKHR; typedef void *cl_api_clEnqueueAcquireD3D10ObjectsKHR; typedef void *cl_api_clEnqueueReleaseD3D10ObjectsKHR; /* cl_khr_d3d11_sharing */ typedef void *cl_api_clGetDeviceIDsFromD3D11KHR; typedef void *cl_api_clCreateFromD3D11BufferKHR; typedef void *cl_api_clCreateFromD3D11Texture2DKHR; typedef void *cl_api_clCreateFromD3D11Texture3DKHR; typedef void *cl_api_clEnqueueAcquireD3D11ObjectsKHR; typedef void *cl_api_clEnqueueReleaseD3D11ObjectsKHR; /* cl_khr_dx9_media_sharing */ typedef void *cl_api_clCreateFromDX9MediaSurfaceKHR; typedef void *cl_api_clEnqueueAcquireDX9MediaSurfacesKHR; typedef void *cl_api_clEnqueueReleaseDX9MediaSurfacesKHR; typedef void *cl_api_clGetDeviceIDsFromDX9MediaAdapterKHR; #endif /* OpenCL 1.1 */ #ifdef CL_VERSION_1_1 typedef cl_int(CL_API_CALL *cl_api_clSetEventCallback)( 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; typedef cl_mem(CL_API_CALL *cl_api_clCreateSubBuffer)( 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_int(CL_API_CALL *cl_api_clSetMemObjectDestructorCallback)( cl_mem /* memobj */, void(CL_CALLBACK * /*pfn_notify*/)(cl_mem /* memobj */, void * /*user_data*/), void * /*user_data */) CL_API_SUFFIX__VERSION_1_1; typedef cl_event(CL_API_CALL *cl_api_clCreateUserEvent)( cl_context /* context */, cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_1; typedef cl_int(CL_API_CALL *cl_api_clSetUserEventStatus)( cl_event /* event */, cl_int /* execution_status */) CL_API_SUFFIX__VERSION_1_1; #else typedef void *cl_api_clSetEventCallback; typedef void *cl_api_clCreateSubBuffer; typedef void *cl_api_clSetMemObjectDestructorCallback; typedef void *cl_api_clCreateUserEvent; typedef void *cl_api_clSetUserEventStatus; #endif typedef cl_int(CL_API_CALL *cl_api_clCreateSubDevicesEXT)( cl_device_id in_device, const cl_device_partition_property_ext *partition_properties, cl_uint num_entries, cl_device_id *out_devices, cl_uint *num_devices); typedef cl_int(CL_API_CALL *cl_api_clRetainDeviceEXT)( cl_device_id device) CL_API_SUFFIX__VERSION_1_0; typedef cl_int(CL_API_CALL *cl_api_clReleaseDeviceEXT)( cl_device_id device) CL_API_SUFFIX__VERSION_1_0; /* cl_khr_egl_image */ typedef cl_mem(CL_API_CALL *cl_api_clCreateFromEGLImageKHR)( cl_context context, CLeglDisplayKHR display, CLeglImageKHR image, cl_mem_flags flags, const cl_egl_image_properties_khr *properties, cl_int *errcode_ret); typedef cl_int(CL_API_CALL *cl_api_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); typedef cl_int(CL_API_CALL *cl_api_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_khr_egl_event */ typedef cl_event(CL_API_CALL *cl_api_clCreateEventFromEGLSyncKHR)( cl_context context, CLeglSyncKHR sync, CLeglDisplayKHR display, cl_int *errcode_ret); #ifdef CL_VERSION_2_1 typedef cl_int(CL_API_CALL *cl_api_clSetDefaultDeviceCommandQueue)( cl_context context, cl_device_id device, cl_command_queue command_queue) CL_API_SUFFIX__VERSION_2_1; typedef cl_program(CL_API_CALL *cl_api_clCreateProgramWithIL)( cl_context context, const void *il, size_t length, cl_int *errcode_ret) CL_API_SUFFIX__VERSION_2_1; typedef cl_int(CL_API_CALL *cl_api_clGetKernelSubGroupInfo)( 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_1; typedef cl_kernel(CL_API_CALL *cl_api_clCloneKernel)( cl_kernel source_kernel, cl_int *errcode_ret) CL_API_SUFFIX__VERSION_2_1; typedef cl_int(CL_API_CALL *cl_api_clEnqueueSVMMigrateMem)( 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 *cl_api_clGetDeviceAndHostTimer)( cl_device_id device, cl_ulong *device_timestamp, cl_ulong *host_timestamp) CL_API_SUFFIX__VERSION_2_1; typedef cl_int(CL_API_CALL *cl_api_clGetHostTimer)( cl_device_id device, cl_ulong *host_timestamp) CL_API_SUFFIX__VERSION_2_1; #else typedef void *cl_api_clSetDefaultDeviceCommandQueue; typedef void *cl_api_clCreateProgramWithIL; typedef void *cl_api_clGetKernelSubGroupInfo; typedef void *cl_api_clCloneKernel; typedef void *cl_api_clEnqueueSVMMigrateMem; typedef void *cl_api_clGetDeviceAndHostTimer; typedef void *cl_api_clGetHostTimer; #endif /* Vendor dispatch table structure */ typedef struct _cl_icd_dispatch { /* OpenCL 1.0 */ cl_api_clGetPlatformIDs clGetPlatformIDs; cl_api_clGetPlatformInfo clGetPlatformInfo; cl_api_clGetDeviceIDs clGetDeviceIDs; cl_api_clGetDeviceInfo clGetDeviceInfo; cl_api_clCreateContext clCreateContext; cl_api_clCreateContextFromType clCreateContextFromType; cl_api_clRetainContext clRetainContext; cl_api_clReleaseContext clReleaseContext; cl_api_clGetContextInfo clGetContextInfo; cl_api_clCreateCommandQueue clCreateCommandQueue; cl_api_clRetainCommandQueue clRetainCommandQueue; cl_api_clReleaseCommandQueue clReleaseCommandQueue; cl_api_clGetCommandQueueInfo clGetCommandQueueInfo; cl_api_clSetCommandQueueProperty clSetCommandQueueProperty; cl_api_clCreateBuffer clCreateBuffer; cl_api_clCreateImage2D clCreateImage2D; cl_api_clCreateImage3D clCreateImage3D; cl_api_clRetainMemObject clRetainMemObject; cl_api_clReleaseMemObject clReleaseMemObject; cl_api_clGetSupportedImageFormats clGetSupportedImageFormats; cl_api_clGetMemObjectInfo clGetMemObjectInfo; cl_api_clGetImageInfo clGetImageInfo; cl_api_clCreateSampler clCreateSampler; cl_api_clRetainSampler clRetainSampler; cl_api_clReleaseSampler clReleaseSampler; cl_api_clGetSamplerInfo clGetSamplerInfo; cl_api_clCreateProgramWithSource clCreateProgramWithSource; cl_api_clCreateProgramWithBinary clCreateProgramWithBinary; cl_api_clRetainProgram clRetainProgram; cl_api_clReleaseProgram clReleaseProgram; cl_api_clBuildProgram clBuildProgram; cl_api_clUnloadCompiler clUnloadCompiler; cl_api_clGetProgramInfo clGetProgramInfo; cl_api_clGetProgramBuildInfo clGetProgramBuildInfo; cl_api_clCreateKernel clCreateKernel; cl_api_clCreateKernelsInProgram clCreateKernelsInProgram; cl_api_clRetainKernel clRetainKernel; cl_api_clReleaseKernel clReleaseKernel; cl_api_clSetKernelArg clSetKernelArg; cl_api_clGetKernelInfo clGetKernelInfo; cl_api_clGetKernelWorkGroupInfo clGetKernelWorkGroupInfo; cl_api_clWaitForEvents clWaitForEvents; cl_api_clGetEventInfo clGetEventInfo; cl_api_clRetainEvent clRetainEvent; cl_api_clReleaseEvent clReleaseEvent; cl_api_clGetEventProfilingInfo clGetEventProfilingInfo; cl_api_clFlush clFlush; cl_api_clFinish clFinish; cl_api_clEnqueueReadBuffer clEnqueueReadBuffer; cl_api_clEnqueueWriteBuffer clEnqueueWriteBuffer; cl_api_clEnqueueCopyBuffer clEnqueueCopyBuffer; cl_api_clEnqueueReadImage clEnqueueReadImage; cl_api_clEnqueueWriteImage clEnqueueWriteImage; cl_api_clEnqueueCopyImage clEnqueueCopyImage; cl_api_clEnqueueCopyImageToBuffer clEnqueueCopyImageToBuffer; cl_api_clEnqueueCopyBufferToImage clEnqueueCopyBufferToImage; cl_api_clEnqueueMapBuffer clEnqueueMapBuffer; cl_api_clEnqueueMapImage clEnqueueMapImage; cl_api_clEnqueueUnmapMemObject clEnqueueUnmapMemObject; cl_api_clEnqueueNDRangeKernel clEnqueueNDRangeKernel; cl_api_clEnqueueTask clEnqueueTask; cl_api_clEnqueueNativeKernel clEnqueueNativeKernel; cl_api_clEnqueueMarker clEnqueueMarker; cl_api_clEnqueueWaitForEvents clEnqueueWaitForEvents; cl_api_clEnqueueBarrier clEnqueueBarrier; cl_api_clGetExtensionFunctionAddress clGetExtensionFunctionAddress; cl_api_clCreateFromGLBuffer clCreateFromGLBuffer; cl_api_clCreateFromGLTexture2D clCreateFromGLTexture2D; cl_api_clCreateFromGLTexture3D clCreateFromGLTexture3D; cl_api_clCreateFromGLRenderbuffer clCreateFromGLRenderbuffer; cl_api_clGetGLObjectInfo clGetGLObjectInfo; cl_api_clGetGLTextureInfo clGetGLTextureInfo; cl_api_clEnqueueAcquireGLObjects clEnqueueAcquireGLObjects; cl_api_clEnqueueReleaseGLObjects clEnqueueReleaseGLObjects; cl_api_clGetGLContextInfoKHR clGetGLContextInfoKHR; /* cl_khr_d3d10_sharing */ cl_api_clGetDeviceIDsFromD3D10KHR clGetDeviceIDsFromD3D10KHR; cl_api_clCreateFromD3D10BufferKHR clCreateFromD3D10BufferKHR; cl_api_clCreateFromD3D10Texture2DKHR clCreateFromD3D10Texture2DKHR; cl_api_clCreateFromD3D10Texture3DKHR clCreateFromD3D10Texture3DKHR; cl_api_clEnqueueAcquireD3D10ObjectsKHR clEnqueueAcquireD3D10ObjectsKHR; cl_api_clEnqueueReleaseD3D10ObjectsKHR clEnqueueReleaseD3D10ObjectsKHR; /* OpenCL 1.1 */ cl_api_clSetEventCallback clSetEventCallback; cl_api_clCreateSubBuffer clCreateSubBuffer; cl_api_clSetMemObjectDestructorCallback clSetMemObjectDestructorCallback; cl_api_clCreateUserEvent clCreateUserEvent; cl_api_clSetUserEventStatus clSetUserEventStatus; cl_api_clEnqueueReadBufferRect clEnqueueReadBufferRect; cl_api_clEnqueueWriteBufferRect clEnqueueWriteBufferRect; cl_api_clEnqueueCopyBufferRect clEnqueueCopyBufferRect; /* cl_ext_device_fission */ cl_api_clCreateSubDevicesEXT clCreateSubDevicesEXT; cl_api_clRetainDeviceEXT clRetainDeviceEXT; cl_api_clReleaseDeviceEXT clReleaseDeviceEXT; /* cl_khr_gl_event */ cl_api_clCreateEventFromGLsyncKHR clCreateEventFromGLsyncKHR; /* OpenCL 1.2 */ cl_api_clCreateSubDevices clCreateSubDevices; cl_api_clRetainDevice clRetainDevice; cl_api_clReleaseDevice clReleaseDevice; cl_api_clCreateImage clCreateImage; cl_api_clCreateProgramWithBuiltInKernels clCreateProgramWithBuiltInKernels; cl_api_clCompileProgram clCompileProgram; cl_api_clLinkProgram clLinkProgram; cl_api_clUnloadPlatformCompiler clUnloadPlatformCompiler; cl_api_clGetKernelArgInfo clGetKernelArgInfo; cl_api_clEnqueueFillBuffer clEnqueueFillBuffer; cl_api_clEnqueueFillImage clEnqueueFillImage; cl_api_clEnqueueMigrateMemObjects clEnqueueMigrateMemObjects; cl_api_clEnqueueMarkerWithWaitList clEnqueueMarkerWithWaitList; cl_api_clEnqueueBarrierWithWaitList clEnqueueBarrierWithWaitList; cl_api_clGetExtensionFunctionAddressForPlatform clGetExtensionFunctionAddressForPlatform; cl_api_clCreateFromGLTexture clCreateFromGLTexture; /* cl_khr_d3d11_sharing */ cl_api_clGetDeviceIDsFromD3D11KHR clGetDeviceIDsFromD3D11KHR; cl_api_clCreateFromD3D11BufferKHR clCreateFromD3D11BufferKHR; cl_api_clCreateFromD3D11Texture2DKHR clCreateFromD3D11Texture2DKHR; cl_api_clCreateFromD3D11Texture3DKHR clCreateFromD3D11Texture3DKHR; cl_api_clCreateFromDX9MediaSurfaceKHR clCreateFromDX9MediaSurfaceKHR; cl_api_clEnqueueAcquireD3D11ObjectsKHR clEnqueueAcquireD3D11ObjectsKHR; cl_api_clEnqueueReleaseD3D11ObjectsKHR clEnqueueReleaseD3D11ObjectsKHR; /* cl_khr_dx9_media_sharing */ cl_api_clGetDeviceIDsFromDX9MediaAdapterKHR clGetDeviceIDsFromDX9MediaAdapterKHR; cl_api_clEnqueueAcquireDX9MediaSurfacesKHR clEnqueueAcquireDX9MediaSurfacesKHR; cl_api_clEnqueueReleaseDX9MediaSurfacesKHR clEnqueueReleaseDX9MediaSurfacesKHR; /* cl_khr_egl_image */ cl_api_clCreateFromEGLImageKHR clCreateFromEGLImageKHR; cl_api_clEnqueueAcquireEGLObjectsKHR clEnqueueAcquireEGLObjectsKHR; cl_api_clEnqueueReleaseEGLObjectsKHR clEnqueueReleaseEGLObjectsKHR; /* cl_khr_egl_event */ cl_api_clCreateEventFromEGLSyncKHR clCreateEventFromEGLSyncKHR; /* OpenCL 2.0 */ cl_api_clCreateCommandQueueWithProperties clCreateCommandQueueWithProperties; cl_api_clCreatePipe clCreatePipe; cl_api_clGetPipeInfo clGetPipeInfo; cl_api_clSVMAlloc clSVMAlloc; cl_api_clSVMFree clSVMFree; cl_api_clEnqueueSVMFree clEnqueueSVMFree; cl_api_clEnqueueSVMMemcpy clEnqueueSVMMemcpy; cl_api_clEnqueueSVMMemFill clEnqueueSVMMemFill; cl_api_clEnqueueSVMMap clEnqueueSVMMap; cl_api_clEnqueueSVMUnmap clEnqueueSVMUnmap; cl_api_clCreateSamplerWithProperties clCreateSamplerWithProperties; cl_api_clSetKernelArgSVMPointer clSetKernelArgSVMPointer; cl_api_clSetKernelExecInfo clSetKernelExecInfo; /* cl_khr_sub_groups */ cl_api_clGetKernelSubGroupInfoKHR clGetKernelSubGroupInfoKHR; /* OpenCL 2.1 */ cl_api_clCloneKernel clCloneKernel; cl_api_clCreateProgramWithIL clCreateProgramWithIL; cl_api_clEnqueueSVMMigrateMem clEnqueueSVMMigrateMem; cl_api_clGetDeviceAndHostTimer clGetDeviceAndHostTimer; cl_api_clGetHostTimer clGetHostTimer; cl_api_clGetKernelSubGroupInfo clGetKernelSubGroupInfo; cl_api_clSetDefaultDeviceCommandQueue clSetDefaultDeviceCommandQueue; /* OpenCL 2.2 */ cl_api_clSetProgramReleaseCallback clSetProgramReleaseCallback; cl_api_clSetProgramSpecializationConstant clSetProgramSpecializationConstant; /* OpenCL 3.0 */ cl_api_clCreateBufferWithProperties clCreateBufferWithProperties; cl_api_clCreateImageWithProperties clCreateImageWithProperties; cl_api_clSetContextDestructorCallback clSetContextDestructorCallback; } cl_icd_dispatch; #ifdef __cplusplus } #endif #endif /* #ifndef OPENCL_CL_ICD_H */ ocl-icd-2.3.3/khronos-headers/CL/cl_layer.h000066400000000000000000000072361477331540600204100ustar00rootroot00000000000000/******************************************************************************* * Copyright (c) 2008-2023 The Khronos Group Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. ******************************************************************************/ #ifndef OPENCL_CL_LAYER_H_ #define OPENCL_CL_LAYER_H_ /* ** This header is generated from the Khronos OpenCL XML API Registry. */ #include #include /* CL_NO_PROTOTYPES implies CL_NO_EXTENSION_PROTOTYPES: */ #if defined(CL_NO_PROTOTYPES) && !defined(CL_NO_EXTENSION_PROTOTYPES) #define CL_NO_EXTENSION_PROTOTYPES #endif /* CL_NO_EXTENSION_PROTOTYPES implies CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES and CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES: */ #if defined(CL_NO_EXTENSION_PROTOTYPES) && \ !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) #define CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES #endif #if defined(CL_NO_EXTENSION_PROTOTYPES) && \ !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) #define CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES #endif #ifdef __cplusplus extern "C" { #endif /*************************************************************** * cl_loader_layers ***************************************************************/ #define cl_loader_layers 1 #define CL_LOADER_LAYERS_EXTENSION_NAME \ "cl_loader_layers" typedef cl_uint cl_layer_info; typedef cl_uint cl_layer_api_version; /* cl_layer_info */ #define CL_LAYER_API_VERSION 0x4240 #define CL_LAYER_NAME 0x4241 /* Misc API enums */ #define CL_LAYER_API_VERSION_100 100 typedef cl_int (CL_API_CALL * clGetLayerInfo_fn)( cl_layer_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret) ; typedef cl_int (CL_API_CALL * clInitLayer_fn)( cl_uint num_entries, const cl_icd_dispatch* target_dispatch, cl_uint* num_entries_ret, const cl_icd_dispatch** layer_dispatch_ret) ; /* ** The function pointer typedefs prefixed with "pfn_" are provided for ** compatibility with earlier versions of the headers. New code is ** encouraged to use the function pointer typedefs that are suffixed with ** "_fn" instead, for consistency. */ typedef cl_int (CL_API_CALL * pfn_clGetLayerInfo)( cl_layer_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret) ; typedef cl_int (CL_API_CALL * pfn_clInitLayer)( cl_uint num_entries, const cl_icd_dispatch* target_dispatch, cl_uint* num_entries_ret, const cl_icd_dispatch** layer_dispatch_ret) ; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL clGetLayerInfo( cl_layer_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret) ; extern CL_API_ENTRY cl_int CL_API_CALL clInitLayer( cl_uint num_entries, const cl_icd_dispatch* target_dispatch, cl_uint* num_entries_ret, const cl_icd_dispatch** layer_dispatch_ret) ; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ #ifdef __cplusplus } #endif #endif /* OPENCL_CL_LAYER_H_ */ ocl-icd-2.3.3/khronos-headers/CL/cl_platform.h000066400000000000000000001246461477331540600211250ustar00rootroot00000000000000/******************************************************************************* * Copyright (c) 2008-2020 The Khronos Group Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. ******************************************************************************/ #ifndef __CL_PLATFORM_H #define __CL_PLATFORM_H #include #ifdef __cplusplus extern "C" { #endif #if defined(_WIN32) #if !defined(CL_API_ENTRY) #define CL_API_ENTRY #endif #if !defined(CL_API_CALL) #define CL_API_CALL __stdcall #endif #if !defined(CL_CALLBACK) #define CL_CALLBACK __stdcall #endif #else #if !defined(CL_API_ENTRY) #define CL_API_ENTRY #endif #if !defined(CL_API_CALL) #define CL_API_CALL #endif #if !defined(CL_CALLBACK) #define CL_CALLBACK #endif #endif /* * Deprecation flags refer to the last version of the header in which the * feature was not deprecated. * * E.g. VERSION_1_1_DEPRECATED means the feature is present in 1.1 without * deprecation but is deprecated in versions later than 1.1. */ #ifndef CL_API_SUFFIX_USER #define CL_API_SUFFIX_USER #endif #ifndef CL_API_PREFIX_USER #define CL_API_PREFIX_USER #endif #define CL_API_SUFFIX_COMMON CL_API_SUFFIX_USER #define CL_API_PREFIX_COMMON CL_API_PREFIX_USER #define CL_API_SUFFIX__VERSION_1_0 CL_API_SUFFIX_COMMON #define CL_API_SUFFIX__VERSION_1_1 CL_API_SUFFIX_COMMON #define CL_API_SUFFIX__VERSION_1_2 CL_API_SUFFIX_COMMON #define CL_API_SUFFIX__VERSION_2_0 CL_API_SUFFIX_COMMON #define CL_API_SUFFIX__VERSION_2_1 CL_API_SUFFIX_COMMON #define CL_API_SUFFIX__VERSION_2_2 CL_API_SUFFIX_COMMON #define CL_API_SUFFIX__VERSION_3_0 CL_API_SUFFIX_COMMON #define CL_API_SUFFIX__EXPERIMENTAL CL_API_SUFFIX_COMMON #ifdef __GNUC__ #define CL_API_SUFFIX_DEPRECATED __attribute__((deprecated)) #define CL_API_PREFIX_DEPRECATED #elif defined(_WIN32) #define CL_API_SUFFIX_DEPRECATED #define CL_API_PREFIX_DEPRECATED __declspec(deprecated) #else #define CL_API_SUFFIX_DEPRECATED #define CL_API_PREFIX_DEPRECATED #endif #ifdef CL_USE_DEPRECATED_OPENCL_1_0_APIS #define CL_API_SUFFIX__VERSION_1_0_DEPRECATED CL_API_SUFFIX_COMMON #define CL_API_PREFIX__VERSION_1_0_DEPRECATED CL_API_PREFIX_COMMON #else #define CL_API_SUFFIX__VERSION_1_0_DEPRECATED CL_API_SUFFIX_COMMON CL_API_SUFFIX_DEPRECATED #define CL_API_PREFIX__VERSION_1_0_DEPRECATED CL_API_PREFIX_COMMON CL_API_PREFIX_DEPRECATED #endif #ifdef CL_USE_DEPRECATED_OPENCL_1_1_APIS #define CL_API_SUFFIX__VERSION_1_1_DEPRECATED CL_API_SUFFIX_COMMON #define CL_API_PREFIX__VERSION_1_1_DEPRECATED CL_API_PREFIX_COMMON #else #define CL_API_SUFFIX__VERSION_1_1_DEPRECATED CL_API_SUFFIX_COMMON CL_API_SUFFIX_DEPRECATED #define CL_API_PREFIX__VERSION_1_1_DEPRECATED CL_API_PREFIX_COMMON CL_API_PREFIX_DEPRECATED #endif #ifdef CL_USE_DEPRECATED_OPENCL_1_2_APIS #define CL_API_SUFFIX__VERSION_1_2_DEPRECATED CL_API_SUFFIX_COMMON #define CL_API_PREFIX__VERSION_1_2_DEPRECATED CL_API_PREFIX_COMMON #else #define CL_API_SUFFIX__VERSION_1_2_DEPRECATED CL_API_SUFFIX_COMMON CL_API_SUFFIX_DEPRECATED #define CL_API_PREFIX__VERSION_1_2_DEPRECATED CL_API_PREFIX_COMMON CL_API_PREFIX_DEPRECATED #endif #ifdef CL_USE_DEPRECATED_OPENCL_2_0_APIS #define CL_API_SUFFIX__VERSION_2_0_DEPRECATED CL_API_SUFFIX_COMMON #define CL_API_PREFIX__VERSION_2_0_DEPRECATED CL_API_PREFIX_COMMON #else #define CL_API_SUFFIX__VERSION_2_0_DEPRECATED CL_API_SUFFIX_COMMON CL_API_SUFFIX_DEPRECATED #define CL_API_PREFIX__VERSION_2_0_DEPRECATED CL_API_PREFIX_COMMON CL_API_PREFIX_DEPRECATED #endif #ifdef CL_USE_DEPRECATED_OPENCL_2_1_APIS #define CL_API_SUFFIX__VERSION_2_1_DEPRECATED CL_API_SUFFIX_COMMON #define CL_API_PREFIX__VERSION_2_1_DEPRECATED CL_API_PREFIX_COMMON #else #define CL_API_SUFFIX__VERSION_2_1_DEPRECATED CL_API_SUFFIX_COMMON CL_API_SUFFIX_DEPRECATED #define CL_API_PREFIX__VERSION_2_1_DEPRECATED CL_API_PREFIX_COMMON CL_API_PREFIX_DEPRECATED #endif #ifdef CL_USE_DEPRECATED_OPENCL_2_2_APIS #define CL_API_SUFFIX__VERSION_2_2_DEPRECATED CL_API_SUFFIX_COMMON #define CL_API_PREFIX__VERSION_2_2_DEPRECATED CL_API_PREFIX_COMMON #else #define CL_API_SUFFIX__VERSION_2_2_DEPRECATED CL_API_SUFFIX_COMMON CL_API_SUFFIX_DEPRECATED #define CL_API_PREFIX__VERSION_2_2_DEPRECATED CL_API_PREFIX_COMMON CL_API_PREFIX_DEPRECATED #endif #if (defined (_WIN32) && defined(_MSC_VER)) #if defined(__clang__) #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wlanguage-extension-token" #endif /* intptr_t is used in cl.h and provided by stddef.h in Visual C++, but not in clang */ /* stdint.h was missing before Visual Studio 2010, include it for later versions and for clang */ #if defined(__clang__) || _MSC_VER >= 1600 #include #endif /* scalar types */ typedef signed __int8 cl_char; typedef unsigned __int8 cl_uchar; typedef signed __int16 cl_short; typedef unsigned __int16 cl_ushort; typedef signed __int32 cl_int; typedef unsigned __int32 cl_uint; typedef signed __int64 cl_long; typedef unsigned __int64 cl_ulong; typedef unsigned __int16 cl_half; typedef float cl_float; typedef double cl_double; #if defined(__clang__) #pragma clang diagnostic pop #endif /* Macro names and corresponding values defined by OpenCL */ #define CL_CHAR_BIT 8 #define CL_SCHAR_MAX 127 #define CL_SCHAR_MIN (-127-1) #define CL_CHAR_MAX CL_SCHAR_MAX #define CL_CHAR_MIN CL_SCHAR_MIN #define CL_UCHAR_MAX 255 #define CL_SHRT_MAX 32767 #define CL_SHRT_MIN (-32767-1) #define CL_USHRT_MAX 65535 #define CL_INT_MAX 2147483647 #define CL_INT_MIN (-2147483647-1) #define CL_UINT_MAX 0xffffffffU #define CL_LONG_MAX ((cl_long) 0x7FFFFFFFFFFFFFFFLL) #define CL_LONG_MIN ((cl_long) -0x7FFFFFFFFFFFFFFFLL - 1LL) #define CL_ULONG_MAX ((cl_ulong) 0xFFFFFFFFFFFFFFFFULL) #define CL_FLT_DIG 6 #define CL_FLT_MANT_DIG 24 #define CL_FLT_MAX_10_EXP +38 #define CL_FLT_MAX_EXP +128 #define CL_FLT_MIN_10_EXP -37 #define CL_FLT_MIN_EXP -125 #define CL_FLT_RADIX 2 #define CL_FLT_MAX 340282346638528859811704183484516925440.0f #define CL_FLT_MIN 1.175494350822287507969e-38f #define CL_FLT_EPSILON 1.1920928955078125e-7f #define CL_HALF_DIG 3 #define CL_HALF_MANT_DIG 11 #define CL_HALF_MAX_10_EXP +4 #define CL_HALF_MAX_EXP +16 #define CL_HALF_MIN_10_EXP -4 #define CL_HALF_MIN_EXP -13 #define CL_HALF_RADIX 2 #define CL_HALF_MAX 65504.0f #define CL_HALF_MIN 6.103515625e-05f #define CL_HALF_EPSILON 9.765625e-04f #define CL_DBL_DIG 15 #define CL_DBL_MANT_DIG 53 #define CL_DBL_MAX_10_EXP +308 #define CL_DBL_MAX_EXP +1024 #define CL_DBL_MIN_10_EXP -307 #define CL_DBL_MIN_EXP -1021 #define CL_DBL_RADIX 2 #define CL_DBL_MAX 1.7976931348623158e+308 #define CL_DBL_MIN 2.225073858507201383090e-308 #define CL_DBL_EPSILON 2.220446049250313080847e-16 #define CL_M_E 2.7182818284590452354 #define CL_M_LOG2E 1.4426950408889634074 #define CL_M_LOG10E 0.43429448190325182765 #define CL_M_LN2 0.69314718055994530942 #define CL_M_LN10 2.30258509299404568402 #define CL_M_PI 3.14159265358979323846 #define CL_M_PI_2 1.57079632679489661923 #define CL_M_PI_4 0.78539816339744830962 #define CL_M_1_PI 0.31830988618379067154 #define CL_M_2_PI 0.63661977236758134308 #define CL_M_2_SQRTPI 1.12837916709551257390 #define CL_M_SQRT2 1.41421356237309504880 #define CL_M_SQRT1_2 0.70710678118654752440 #define CL_M_E_F 2.718281828f #define CL_M_LOG2E_F 1.442695041f #define CL_M_LOG10E_F 0.434294482f #define CL_M_LN2_F 0.693147181f #define CL_M_LN10_F 2.302585093f #define CL_M_PI_F 3.141592654f #define CL_M_PI_2_F 1.570796327f #define CL_M_PI_4_F 0.785398163f #define CL_M_1_PI_F 0.318309886f #define CL_M_2_PI_F 0.636619772f #define CL_M_2_SQRTPI_F 1.128379167f #define CL_M_SQRT2_F 1.414213562f #define CL_M_SQRT1_2_F 0.707106781f #define CL_NAN (CL_INFINITY - CL_INFINITY) #define CL_HUGE_VALF ((cl_float) 1e50) #define CL_HUGE_VAL ((cl_double) 1e500) #define CL_MAXFLOAT CL_FLT_MAX #define CL_INFINITY CL_HUGE_VALF #else #include /* scalar types */ typedef int8_t cl_char; typedef uint8_t cl_uchar; typedef int16_t cl_short; typedef uint16_t cl_ushort; typedef int32_t cl_int; typedef uint32_t cl_uint; typedef int64_t cl_long; typedef uint64_t cl_ulong; typedef uint16_t cl_half; typedef float cl_float; typedef double cl_double; /* Macro names and corresponding values defined by OpenCL */ #define CL_CHAR_BIT 8 #define CL_SCHAR_MAX 127 #define CL_SCHAR_MIN (-127-1) #define CL_CHAR_MAX CL_SCHAR_MAX #define CL_CHAR_MIN CL_SCHAR_MIN #define CL_UCHAR_MAX 255 #define CL_SHRT_MAX 32767 #define CL_SHRT_MIN (-32767-1) #define CL_USHRT_MAX 65535 #define CL_INT_MAX 2147483647 #define CL_INT_MIN (-2147483647-1) #define CL_UINT_MAX 0xffffffffU #define CL_LONG_MAX ((cl_long) 0x7FFFFFFFFFFFFFFFLL) #define CL_LONG_MIN ((cl_long) -0x7FFFFFFFFFFFFFFFLL - 1LL) #define CL_ULONG_MAX ((cl_ulong) 0xFFFFFFFFFFFFFFFFULL) #define CL_FLT_DIG 6 #define CL_FLT_MANT_DIG 24 #define CL_FLT_MAX_10_EXP +38 #define CL_FLT_MAX_EXP +128 #define CL_FLT_MIN_10_EXP -37 #define CL_FLT_MIN_EXP -125 #define CL_FLT_RADIX 2 #define CL_FLT_MAX 340282346638528859811704183484516925440.0f #define CL_FLT_MIN 1.175494350822287507969e-38f #define CL_FLT_EPSILON 1.1920928955078125e-7f #define CL_HALF_DIG 3 #define CL_HALF_MANT_DIG 11 #define CL_HALF_MAX_10_EXP +4 #define CL_HALF_MAX_EXP +16 #define CL_HALF_MIN_10_EXP -4 #define CL_HALF_MIN_EXP -13 #define CL_HALF_RADIX 2 #define CL_HALF_MAX 65504.0f #define CL_HALF_MIN 6.103515625e-05f #define CL_HALF_EPSILON 9.765625e-04f #define CL_DBL_DIG 15 #define CL_DBL_MANT_DIG 53 #define CL_DBL_MAX_10_EXP +308 #define CL_DBL_MAX_EXP +1024 #define CL_DBL_MIN_10_EXP -307 #define CL_DBL_MIN_EXP -1021 #define CL_DBL_RADIX 2 #define CL_DBL_MAX 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.0 #define CL_DBL_MIN 2.225073858507201383090e-308 #define CL_DBL_EPSILON 2.220446049250313080847e-16 #define CL_M_E 2.7182818284590452354 #define CL_M_LOG2E 1.4426950408889634074 #define CL_M_LOG10E 0.43429448190325182765 #define CL_M_LN2 0.69314718055994530942 #define CL_M_LN10 2.30258509299404568402 #define CL_M_PI 3.14159265358979323846 #define CL_M_PI_2 1.57079632679489661923 #define CL_M_PI_4 0.78539816339744830962 #define CL_M_1_PI 0.31830988618379067154 #define CL_M_2_PI 0.63661977236758134308 #define CL_M_2_SQRTPI 1.12837916709551257390 #define CL_M_SQRT2 1.41421356237309504880 #define CL_M_SQRT1_2 0.70710678118654752440 #define CL_M_E_F 2.718281828f #define CL_M_LOG2E_F 1.442695041f #define CL_M_LOG10E_F 0.434294482f #define CL_M_LN2_F 0.693147181f #define CL_M_LN10_F 2.302585093f #define CL_M_PI_F 3.141592654f #define CL_M_PI_2_F 1.570796327f #define CL_M_PI_4_F 0.785398163f #define CL_M_1_PI_F 0.318309886f #define CL_M_2_PI_F 0.636619772f #define CL_M_2_SQRTPI_F 1.128379167f #define CL_M_SQRT2_F 1.414213562f #define CL_M_SQRT1_2_F 0.707106781f #if defined( __GNUC__ ) #define CL_HUGE_VALF __builtin_huge_valf() #define CL_HUGE_VAL __builtin_huge_val() #define CL_NAN __builtin_nanf( "" ) #else #define CL_HUGE_VALF ((cl_float) 1e50) #define CL_HUGE_VAL ((cl_double) 1e500) float nanf( const char * ); #define CL_NAN nanf( "" ) #endif #define CL_MAXFLOAT CL_FLT_MAX #define CL_INFINITY CL_HUGE_VALF #endif #include /* Mirror types to GL types. Mirror types allow us to avoid deciding which 87s to load based on whether we are using GL or GLES here. */ typedef unsigned int cl_GLuint; typedef int cl_GLint; typedef unsigned int cl_GLenum; /* * Vector types * * Note: OpenCL requires that all types be naturally aligned. * This means that vector types must be naturally aligned. * For example, a vector of four floats must be aligned to * a 16 byte boundary (calculated as 4 * the natural 4-byte * alignment of the float). The alignment qualifiers here * will only function properly if your compiler supports them * and if you don't actively work to defeat them. For example, * in order for a cl_float4 to be 16 byte aligned in a struct, * the start of the struct must itself be 16-byte aligned. * * Maintaining proper alignment is the user's responsibility. */ /* Define basic vector types */ #if defined( __VEC__ ) #if !defined(__clang__) #include /* may be omitted depending on compiler. AltiVec spec provides no way to detect whether the header is required. */ #endif typedef __vector unsigned char __cl_uchar16; typedef __vector signed char __cl_char16; typedef __vector unsigned short __cl_ushort8; typedef __vector signed short __cl_short8; typedef __vector unsigned int __cl_uint4; typedef __vector signed int __cl_int4; typedef __vector float __cl_float4; #define __CL_UCHAR16__ 1 #define __CL_CHAR16__ 1 #define __CL_USHORT8__ 1 #define __CL_SHORT8__ 1 #define __CL_UINT4__ 1 #define __CL_INT4__ 1 #define __CL_FLOAT4__ 1 #endif #if defined( __SSE__ ) #if defined( __MINGW64__ ) #include #else #include #endif #if defined( __GNUC__ ) typedef float __cl_float4 __attribute__((vector_size(16))); #else typedef __m128 __cl_float4; #endif #define __CL_FLOAT4__ 1 #endif #if defined( __SSE2__ ) #if defined( __MINGW64__ ) #include #else #include #endif #if defined( __GNUC__ ) typedef cl_uchar __cl_uchar16 __attribute__((vector_size(16))); typedef cl_char __cl_char16 __attribute__((vector_size(16))); typedef cl_ushort __cl_ushort8 __attribute__((vector_size(16))); typedef cl_short __cl_short8 __attribute__((vector_size(16))); typedef cl_uint __cl_uint4 __attribute__((vector_size(16))); typedef cl_int __cl_int4 __attribute__((vector_size(16))); typedef cl_ulong __cl_ulong2 __attribute__((vector_size(16))); typedef cl_long __cl_long2 __attribute__((vector_size(16))); typedef cl_double __cl_double2 __attribute__((vector_size(16))); #else typedef __m128i __cl_uchar16; typedef __m128i __cl_char16; typedef __m128i __cl_ushort8; typedef __m128i __cl_short8; typedef __m128i __cl_uint4; typedef __m128i __cl_int4; typedef __m128i __cl_ulong2; typedef __m128i __cl_long2; typedef __m128d __cl_double2; #endif #define __CL_UCHAR16__ 1 #define __CL_CHAR16__ 1 #define __CL_USHORT8__ 1 #define __CL_SHORT8__ 1 #define __CL_INT4__ 1 #define __CL_UINT4__ 1 #define __CL_ULONG2__ 1 #define __CL_LONG2__ 1 #define __CL_DOUBLE2__ 1 #endif #if defined( __MMX__ ) #include #if defined( __GNUC__ ) typedef cl_uchar __cl_uchar8 __attribute__((vector_size(8))); typedef cl_char __cl_char8 __attribute__((vector_size(8))); typedef cl_ushort __cl_ushort4 __attribute__((vector_size(8))); typedef cl_short __cl_short4 __attribute__((vector_size(8))); typedef cl_uint __cl_uint2 __attribute__((vector_size(8))); typedef cl_int __cl_int2 __attribute__((vector_size(8))); typedef cl_ulong __cl_ulong1 __attribute__((vector_size(8))); typedef cl_long __cl_long1 __attribute__((vector_size(8))); typedef cl_float __cl_float2 __attribute__((vector_size(8))); #else typedef __m64 __cl_uchar8; typedef __m64 __cl_char8; typedef __m64 __cl_ushort4; typedef __m64 __cl_short4; typedef __m64 __cl_uint2; typedef __m64 __cl_int2; typedef __m64 __cl_ulong1; typedef __m64 __cl_long1; typedef __m64 __cl_float2; #endif #define __CL_UCHAR8__ 1 #define __CL_CHAR8__ 1 #define __CL_USHORT4__ 1 #define __CL_SHORT4__ 1 #define __CL_INT2__ 1 #define __CL_UINT2__ 1 #define __CL_ULONG1__ 1 #define __CL_LONG1__ 1 #define __CL_FLOAT2__ 1 #endif #if defined( __AVX__ ) #if defined( __MINGW64__ ) #include #else #include #endif #if defined( __GNUC__ ) typedef cl_float __cl_float8 __attribute__((vector_size(32))); typedef cl_double __cl_double4 __attribute__((vector_size(32))); #else typedef __m256 __cl_float8; typedef __m256d __cl_double4; #endif #define __CL_FLOAT8__ 1 #define __CL_DOUBLE4__ 1 #endif /* Define capabilities for anonymous struct members. */ #if !defined(__cplusplus) && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L #define __CL_HAS_ANON_STRUCT__ 1 #define __CL_ANON_STRUCT__ #elif defined(_WIN32) && defined(_MSC_VER) && !defined(__STDC__) #define __CL_HAS_ANON_STRUCT__ 1 #define __CL_ANON_STRUCT__ #elif defined(__GNUC__) && ! defined(__STRICT_ANSI__) #define __CL_HAS_ANON_STRUCT__ 1 #define __CL_ANON_STRUCT__ __extension__ #elif defined(__clang__) #define __CL_HAS_ANON_STRUCT__ 1 #define __CL_ANON_STRUCT__ __extension__ #else #define __CL_HAS_ANON_STRUCT__ 0 #define __CL_ANON_STRUCT__ #endif #if defined(_WIN32) && defined(_MSC_VER) && __CL_HAS_ANON_STRUCT__ /* Disable warning C4201: nonstandard extension used : nameless struct/union */ #pragma warning( push ) #pragma warning( disable : 4201 ) #endif /* Define alignment keys */ #if defined( __GNUC__ ) || defined(__INTEGRITY) #define CL_ALIGNED(_x) __attribute__ ((aligned(_x))) #elif defined( _WIN32) && (_MSC_VER) /* Alignment keys neutered on windows because MSVC can't swallow function arguments with alignment requirements */ /* http://msdn.microsoft.com/en-us/library/373ak2y1%28VS.71%29.aspx */ /* #include */ /* #define CL_ALIGNED(_x) _CRT_ALIGN(_x) */ #define CL_ALIGNED(_x) #else #warning Need to implement some method to align data here #define CL_ALIGNED(_x) #endif /* Indicate whether .xyzw, .s0123 and .hi.lo are supported */ #if __CL_HAS_ANON_STRUCT__ /* .xyzw and .s0123...{f|F} are supported */ #define CL_HAS_NAMED_VECTOR_FIELDS 1 /* .hi and .lo are supported */ #define CL_HAS_HI_LO_VECTOR_FIELDS 1 #endif /* Define cl_vector types */ /* ---- cl_charn ---- */ typedef union { cl_char CL_ALIGNED(2) s[2]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_char x, y; }; __CL_ANON_STRUCT__ struct{ cl_char s0, s1; }; __CL_ANON_STRUCT__ struct{ cl_char lo, hi; }; #endif #if defined( __CL_CHAR2__) __cl_char2 v2; #endif }cl_char2; typedef union { cl_char CL_ALIGNED(4) s[4]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_char x, y, z, w; }; __CL_ANON_STRUCT__ struct{ cl_char s0, s1, s2, s3; }; __CL_ANON_STRUCT__ struct{ cl_char2 lo, hi; }; #endif #if defined( __CL_CHAR2__) __cl_char2 v2[2]; #endif #if defined( __CL_CHAR4__) __cl_char4 v4; #endif }cl_char4; /* cl_char3 is identical in size, alignment and behavior to cl_char4. See section 6.1.5. */ typedef cl_char4 cl_char3; typedef union { cl_char CL_ALIGNED(8) s[8]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_char x, y, z, w; }; __CL_ANON_STRUCT__ struct{ cl_char s0, s1, s2, s3, s4, s5, s6, s7; }; __CL_ANON_STRUCT__ struct{ cl_char4 lo, hi; }; #endif #if defined( __CL_CHAR2__) __cl_char2 v2[4]; #endif #if defined( __CL_CHAR4__) __cl_char4 v4[2]; #endif #if defined( __CL_CHAR8__ ) __cl_char8 v8; #endif }cl_char8; typedef union { cl_char CL_ALIGNED(16) s[16]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_char x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; __CL_ANON_STRUCT__ struct{ cl_char s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; __CL_ANON_STRUCT__ struct{ cl_char8 lo, hi; }; #endif #if defined( __CL_CHAR2__) __cl_char2 v2[8]; #endif #if defined( __CL_CHAR4__) __cl_char4 v4[4]; #endif #if defined( __CL_CHAR8__ ) __cl_char8 v8[2]; #endif #if defined( __CL_CHAR16__ ) __cl_char16 v16; #endif }cl_char16; /* ---- cl_ucharn ---- */ typedef union { cl_uchar CL_ALIGNED(2) s[2]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_uchar x, y; }; __CL_ANON_STRUCT__ struct{ cl_uchar s0, s1; }; __CL_ANON_STRUCT__ struct{ cl_uchar lo, hi; }; #endif #if defined( __cl_uchar2__) __cl_uchar2 v2; #endif }cl_uchar2; typedef union { cl_uchar CL_ALIGNED(4) s[4]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_uchar x, y, z, w; }; __CL_ANON_STRUCT__ struct{ cl_uchar s0, s1, s2, s3; }; __CL_ANON_STRUCT__ struct{ cl_uchar2 lo, hi; }; #endif #if defined( __CL_UCHAR2__) __cl_uchar2 v2[2]; #endif #if defined( __CL_UCHAR4__) __cl_uchar4 v4; #endif }cl_uchar4; /* cl_uchar3 is identical in size, alignment and behavior to cl_uchar4. See section 6.1.5. */ typedef cl_uchar4 cl_uchar3; typedef union { cl_uchar CL_ALIGNED(8) s[8]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_uchar x, y, z, w; }; __CL_ANON_STRUCT__ struct{ cl_uchar s0, s1, s2, s3, s4, s5, s6, s7; }; __CL_ANON_STRUCT__ struct{ cl_uchar4 lo, hi; }; #endif #if defined( __CL_UCHAR2__) __cl_uchar2 v2[4]; #endif #if defined( __CL_UCHAR4__) __cl_uchar4 v4[2]; #endif #if defined( __CL_UCHAR8__ ) __cl_uchar8 v8; #endif }cl_uchar8; typedef union { cl_uchar CL_ALIGNED(16) s[16]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_uchar x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; __CL_ANON_STRUCT__ struct{ cl_uchar s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; __CL_ANON_STRUCT__ struct{ cl_uchar8 lo, hi; }; #endif #if defined( __CL_UCHAR2__) __cl_uchar2 v2[8]; #endif #if defined( __CL_UCHAR4__) __cl_uchar4 v4[4]; #endif #if defined( __CL_UCHAR8__ ) __cl_uchar8 v8[2]; #endif #if defined( __CL_UCHAR16__ ) __cl_uchar16 v16; #endif }cl_uchar16; /* ---- cl_shortn ---- */ typedef union { cl_short CL_ALIGNED(4) s[2]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_short x, y; }; __CL_ANON_STRUCT__ struct{ cl_short s0, s1; }; __CL_ANON_STRUCT__ struct{ cl_short lo, hi; }; #endif #if defined( __CL_SHORT2__) __cl_short2 v2; #endif }cl_short2; typedef union { cl_short CL_ALIGNED(8) s[4]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_short x, y, z, w; }; __CL_ANON_STRUCT__ struct{ cl_short s0, s1, s2, s3; }; __CL_ANON_STRUCT__ struct{ cl_short2 lo, hi; }; #endif #if defined( __CL_SHORT2__) __cl_short2 v2[2]; #endif #if defined( __CL_SHORT4__) __cl_short4 v4; #endif }cl_short4; /* cl_short3 is identical in size, alignment and behavior to cl_short4. See section 6.1.5. */ typedef cl_short4 cl_short3; typedef union { cl_short CL_ALIGNED(16) s[8]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_short x, y, z, w; }; __CL_ANON_STRUCT__ struct{ cl_short s0, s1, s2, s3, s4, s5, s6, s7; }; __CL_ANON_STRUCT__ struct{ cl_short4 lo, hi; }; #endif #if defined( __CL_SHORT2__) __cl_short2 v2[4]; #endif #if defined( __CL_SHORT4__) __cl_short4 v4[2]; #endif #if defined( __CL_SHORT8__ ) __cl_short8 v8; #endif }cl_short8; typedef union { cl_short CL_ALIGNED(32) s[16]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_short x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; __CL_ANON_STRUCT__ struct{ cl_short s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; __CL_ANON_STRUCT__ struct{ cl_short8 lo, hi; }; #endif #if defined( __CL_SHORT2__) __cl_short2 v2[8]; #endif #if defined( __CL_SHORT4__) __cl_short4 v4[4]; #endif #if defined( __CL_SHORT8__ ) __cl_short8 v8[2]; #endif #if defined( __CL_SHORT16__ ) __cl_short16 v16; #endif }cl_short16; /* ---- cl_ushortn ---- */ typedef union { cl_ushort CL_ALIGNED(4) s[2]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_ushort x, y; }; __CL_ANON_STRUCT__ struct{ cl_ushort s0, s1; }; __CL_ANON_STRUCT__ struct{ cl_ushort lo, hi; }; #endif #if defined( __CL_USHORT2__) __cl_ushort2 v2; #endif }cl_ushort2; typedef union { cl_ushort CL_ALIGNED(8) s[4]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_ushort x, y, z, w; }; __CL_ANON_STRUCT__ struct{ cl_ushort s0, s1, s2, s3; }; __CL_ANON_STRUCT__ struct{ cl_ushort2 lo, hi; }; #endif #if defined( __CL_USHORT2__) __cl_ushort2 v2[2]; #endif #if defined( __CL_USHORT4__) __cl_ushort4 v4; #endif }cl_ushort4; /* cl_ushort3 is identical in size, alignment and behavior to cl_ushort4. See section 6.1.5. */ typedef cl_ushort4 cl_ushort3; typedef union { cl_ushort CL_ALIGNED(16) s[8]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_ushort x, y, z, w; }; __CL_ANON_STRUCT__ struct{ cl_ushort s0, s1, s2, s3, s4, s5, s6, s7; }; __CL_ANON_STRUCT__ struct{ cl_ushort4 lo, hi; }; #endif #if defined( __CL_USHORT2__) __cl_ushort2 v2[4]; #endif #if defined( __CL_USHORT4__) __cl_ushort4 v4[2]; #endif #if defined( __CL_USHORT8__ ) __cl_ushort8 v8; #endif }cl_ushort8; typedef union { cl_ushort CL_ALIGNED(32) s[16]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_ushort x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; __CL_ANON_STRUCT__ struct{ cl_ushort s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; __CL_ANON_STRUCT__ struct{ cl_ushort8 lo, hi; }; #endif #if defined( __CL_USHORT2__) __cl_ushort2 v2[8]; #endif #if defined( __CL_USHORT4__) __cl_ushort4 v4[4]; #endif #if defined( __CL_USHORT8__ ) __cl_ushort8 v8[2]; #endif #if defined( __CL_USHORT16__ ) __cl_ushort16 v16; #endif }cl_ushort16; /* ---- cl_halfn ---- */ typedef union { cl_half CL_ALIGNED(4) s[2]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_half x, y; }; __CL_ANON_STRUCT__ struct{ cl_half s0, s1; }; __CL_ANON_STRUCT__ struct{ cl_half lo, hi; }; #endif #if defined( __CL_HALF2__) __cl_half2 v2; #endif }cl_half2; typedef union { cl_half CL_ALIGNED(8) s[4]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_half x, y, z, w; }; __CL_ANON_STRUCT__ struct{ cl_half s0, s1, s2, s3; }; __CL_ANON_STRUCT__ struct{ cl_half2 lo, hi; }; #endif #if defined( __CL_HALF2__) __cl_half2 v2[2]; #endif #if defined( __CL_HALF4__) __cl_half4 v4; #endif }cl_half4; /* cl_half3 is identical in size, alignment and behavior to cl_half4. See section 6.1.5. */ typedef cl_half4 cl_half3; typedef union { cl_half CL_ALIGNED(16) s[8]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_half x, y, z, w; }; __CL_ANON_STRUCT__ struct{ cl_half s0, s1, s2, s3, s4, s5, s6, s7; }; __CL_ANON_STRUCT__ struct{ cl_half4 lo, hi; }; #endif #if defined( __CL_HALF2__) __cl_half2 v2[4]; #endif #if defined( __CL_HALF4__) __cl_half4 v4[2]; #endif #if defined( __CL_HALF8__ ) __cl_half8 v8; #endif }cl_half8; typedef union { cl_half CL_ALIGNED(32) s[16]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_half x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; __CL_ANON_STRUCT__ struct{ cl_half s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; __CL_ANON_STRUCT__ struct{ cl_half8 lo, hi; }; #endif #if defined( __CL_HALF2__) __cl_half2 v2[8]; #endif #if defined( __CL_HALF4__) __cl_half4 v4[4]; #endif #if defined( __CL_HALF8__ ) __cl_half8 v8[2]; #endif #if defined( __CL_HALF16__ ) __cl_half16 v16; #endif }cl_half16; /* ---- cl_intn ---- */ typedef union { cl_int CL_ALIGNED(8) s[2]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_int x, y; }; __CL_ANON_STRUCT__ struct{ cl_int s0, s1; }; __CL_ANON_STRUCT__ struct{ cl_int lo, hi; }; #endif #if defined( __CL_INT2__) __cl_int2 v2; #endif }cl_int2; typedef union { cl_int CL_ALIGNED(16) s[4]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_int x, y, z, w; }; __CL_ANON_STRUCT__ struct{ cl_int s0, s1, s2, s3; }; __CL_ANON_STRUCT__ struct{ cl_int2 lo, hi; }; #endif #if defined( __CL_INT2__) __cl_int2 v2[2]; #endif #if defined( __CL_INT4__) __cl_int4 v4; #endif }cl_int4; /* cl_int3 is identical in size, alignment and behavior to cl_int4. See section 6.1.5. */ typedef cl_int4 cl_int3; typedef union { cl_int CL_ALIGNED(32) s[8]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_int x, y, z, w; }; __CL_ANON_STRUCT__ struct{ cl_int s0, s1, s2, s3, s4, s5, s6, s7; }; __CL_ANON_STRUCT__ struct{ cl_int4 lo, hi; }; #endif #if defined( __CL_INT2__) __cl_int2 v2[4]; #endif #if defined( __CL_INT4__) __cl_int4 v4[2]; #endif #if defined( __CL_INT8__ ) __cl_int8 v8; #endif }cl_int8; typedef union { cl_int CL_ALIGNED(64) s[16]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_int x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; __CL_ANON_STRUCT__ struct{ cl_int s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; __CL_ANON_STRUCT__ struct{ cl_int8 lo, hi; }; #endif #if defined( __CL_INT2__) __cl_int2 v2[8]; #endif #if defined( __CL_INT4__) __cl_int4 v4[4]; #endif #if defined( __CL_INT8__ ) __cl_int8 v8[2]; #endif #if defined( __CL_INT16__ ) __cl_int16 v16; #endif }cl_int16; /* ---- cl_uintn ---- */ typedef union { cl_uint CL_ALIGNED(8) s[2]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_uint x, y; }; __CL_ANON_STRUCT__ struct{ cl_uint s0, s1; }; __CL_ANON_STRUCT__ struct{ cl_uint lo, hi; }; #endif #if defined( __CL_UINT2__) __cl_uint2 v2; #endif }cl_uint2; typedef union { cl_uint CL_ALIGNED(16) s[4]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_uint x, y, z, w; }; __CL_ANON_STRUCT__ struct{ cl_uint s0, s1, s2, s3; }; __CL_ANON_STRUCT__ struct{ cl_uint2 lo, hi; }; #endif #if defined( __CL_UINT2__) __cl_uint2 v2[2]; #endif #if defined( __CL_UINT4__) __cl_uint4 v4; #endif }cl_uint4; /* cl_uint3 is identical in size, alignment and behavior to cl_uint4. See section 6.1.5. */ typedef cl_uint4 cl_uint3; typedef union { cl_uint CL_ALIGNED(32) s[8]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_uint x, y, z, w; }; __CL_ANON_STRUCT__ struct{ cl_uint s0, s1, s2, s3, s4, s5, s6, s7; }; __CL_ANON_STRUCT__ struct{ cl_uint4 lo, hi; }; #endif #if defined( __CL_UINT2__) __cl_uint2 v2[4]; #endif #if defined( __CL_UINT4__) __cl_uint4 v4[2]; #endif #if defined( __CL_UINT8__ ) __cl_uint8 v8; #endif }cl_uint8; typedef union { cl_uint CL_ALIGNED(64) s[16]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_uint x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; __CL_ANON_STRUCT__ struct{ cl_uint s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; __CL_ANON_STRUCT__ struct{ cl_uint8 lo, hi; }; #endif #if defined( __CL_UINT2__) __cl_uint2 v2[8]; #endif #if defined( __CL_UINT4__) __cl_uint4 v4[4]; #endif #if defined( __CL_UINT8__ ) __cl_uint8 v8[2]; #endif #if defined( __CL_UINT16__ ) __cl_uint16 v16; #endif }cl_uint16; /* ---- cl_longn ---- */ typedef union { cl_long CL_ALIGNED(16) s[2]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_long x, y; }; __CL_ANON_STRUCT__ struct{ cl_long s0, s1; }; __CL_ANON_STRUCT__ struct{ cl_long lo, hi; }; #endif #if defined( __CL_LONG2__) __cl_long2 v2; #endif }cl_long2; typedef union { cl_long CL_ALIGNED(32) s[4]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_long x, y, z, w; }; __CL_ANON_STRUCT__ struct{ cl_long s0, s1, s2, s3; }; __CL_ANON_STRUCT__ struct{ cl_long2 lo, hi; }; #endif #if defined( __CL_LONG2__) __cl_long2 v2[2]; #endif #if defined( __CL_LONG4__) __cl_long4 v4; #endif }cl_long4; /* cl_long3 is identical in size, alignment and behavior to cl_long4. See section 6.1.5. */ typedef cl_long4 cl_long3; typedef union { cl_long CL_ALIGNED(64) s[8]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_long x, y, z, w; }; __CL_ANON_STRUCT__ struct{ cl_long s0, s1, s2, s3, s4, s5, s6, s7; }; __CL_ANON_STRUCT__ struct{ cl_long4 lo, hi; }; #endif #if defined( __CL_LONG2__) __cl_long2 v2[4]; #endif #if defined( __CL_LONG4__) __cl_long4 v4[2]; #endif #if defined( __CL_LONG8__ ) __cl_long8 v8; #endif }cl_long8; typedef union { cl_long CL_ALIGNED(128) s[16]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_long x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; __CL_ANON_STRUCT__ struct{ cl_long s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; __CL_ANON_STRUCT__ struct{ cl_long8 lo, hi; }; #endif #if defined( __CL_LONG2__) __cl_long2 v2[8]; #endif #if defined( __CL_LONG4__) __cl_long4 v4[4]; #endif #if defined( __CL_LONG8__ ) __cl_long8 v8[2]; #endif #if defined( __CL_LONG16__ ) __cl_long16 v16; #endif }cl_long16; /* ---- cl_ulongn ---- */ typedef union { cl_ulong CL_ALIGNED(16) s[2]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_ulong x, y; }; __CL_ANON_STRUCT__ struct{ cl_ulong s0, s1; }; __CL_ANON_STRUCT__ struct{ cl_ulong lo, hi; }; #endif #if defined( __CL_ULONG2__) __cl_ulong2 v2; #endif }cl_ulong2; typedef union { cl_ulong CL_ALIGNED(32) s[4]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_ulong x, y, z, w; }; __CL_ANON_STRUCT__ struct{ cl_ulong s0, s1, s2, s3; }; __CL_ANON_STRUCT__ struct{ cl_ulong2 lo, hi; }; #endif #if defined( __CL_ULONG2__) __cl_ulong2 v2[2]; #endif #if defined( __CL_ULONG4__) __cl_ulong4 v4; #endif }cl_ulong4; /* cl_ulong3 is identical in size, alignment and behavior to cl_ulong4. See section 6.1.5. */ typedef cl_ulong4 cl_ulong3; typedef union { cl_ulong CL_ALIGNED(64) s[8]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_ulong x, y, z, w; }; __CL_ANON_STRUCT__ struct{ cl_ulong s0, s1, s2, s3, s4, s5, s6, s7; }; __CL_ANON_STRUCT__ struct{ cl_ulong4 lo, hi; }; #endif #if defined( __CL_ULONG2__) __cl_ulong2 v2[4]; #endif #if defined( __CL_ULONG4__) __cl_ulong4 v4[2]; #endif #if defined( __CL_ULONG8__ ) __cl_ulong8 v8; #endif }cl_ulong8; typedef union { cl_ulong CL_ALIGNED(128) s[16]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_ulong x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; __CL_ANON_STRUCT__ struct{ cl_ulong s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; __CL_ANON_STRUCT__ struct{ cl_ulong8 lo, hi; }; #endif #if defined( __CL_ULONG2__) __cl_ulong2 v2[8]; #endif #if defined( __CL_ULONG4__) __cl_ulong4 v4[4]; #endif #if defined( __CL_ULONG8__ ) __cl_ulong8 v8[2]; #endif #if defined( __CL_ULONG16__ ) __cl_ulong16 v16; #endif }cl_ulong16; /* --- cl_floatn ---- */ typedef union { cl_float CL_ALIGNED(8) s[2]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_float x, y; }; __CL_ANON_STRUCT__ struct{ cl_float s0, s1; }; __CL_ANON_STRUCT__ struct{ cl_float lo, hi; }; #endif #if defined( __CL_FLOAT2__) __cl_float2 v2; #endif }cl_float2; typedef union { cl_float CL_ALIGNED(16) s[4]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_float x, y, z, w; }; __CL_ANON_STRUCT__ struct{ cl_float s0, s1, s2, s3; }; __CL_ANON_STRUCT__ struct{ cl_float2 lo, hi; }; #endif #if defined( __CL_FLOAT2__) __cl_float2 v2[2]; #endif #if defined( __CL_FLOAT4__) __cl_float4 v4; #endif }cl_float4; /* cl_float3 is identical in size, alignment and behavior to cl_float4. See section 6.1.5. */ typedef cl_float4 cl_float3; typedef union { cl_float CL_ALIGNED(32) s[8]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_float x, y, z, w; }; __CL_ANON_STRUCT__ struct{ cl_float s0, s1, s2, s3, s4, s5, s6, s7; }; __CL_ANON_STRUCT__ struct{ cl_float4 lo, hi; }; #endif #if defined( __CL_FLOAT2__) __cl_float2 v2[4]; #endif #if defined( __CL_FLOAT4__) __cl_float4 v4[2]; #endif #if defined( __CL_FLOAT8__ ) __cl_float8 v8; #endif }cl_float8; typedef union { cl_float CL_ALIGNED(64) s[16]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_float x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; __CL_ANON_STRUCT__ struct{ cl_float s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; __CL_ANON_STRUCT__ struct{ cl_float8 lo, hi; }; #endif #if defined( __CL_FLOAT2__) __cl_float2 v2[8]; #endif #if defined( __CL_FLOAT4__) __cl_float4 v4[4]; #endif #if defined( __CL_FLOAT8__ ) __cl_float8 v8[2]; #endif #if defined( __CL_FLOAT16__ ) __cl_float16 v16; #endif }cl_float16; /* --- cl_doublen ---- */ typedef union { cl_double CL_ALIGNED(16) s[2]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_double x, y; }; __CL_ANON_STRUCT__ struct{ cl_double s0, s1; }; __CL_ANON_STRUCT__ struct{ cl_double lo, hi; }; #endif #if defined( __CL_DOUBLE2__) __cl_double2 v2; #endif }cl_double2; typedef union { cl_double CL_ALIGNED(32) s[4]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_double x, y, z, w; }; __CL_ANON_STRUCT__ struct{ cl_double s0, s1, s2, s3; }; __CL_ANON_STRUCT__ struct{ cl_double2 lo, hi; }; #endif #if defined( __CL_DOUBLE2__) __cl_double2 v2[2]; #endif #if defined( __CL_DOUBLE4__) __cl_double4 v4; #endif }cl_double4; /* cl_double3 is identical in size, alignment and behavior to cl_double4. See section 6.1.5. */ typedef cl_double4 cl_double3; typedef union { cl_double CL_ALIGNED(64) s[8]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_double x, y, z, w; }; __CL_ANON_STRUCT__ struct{ cl_double s0, s1, s2, s3, s4, s5, s6, s7; }; __CL_ANON_STRUCT__ struct{ cl_double4 lo, hi; }; #endif #if defined( __CL_DOUBLE2__) __cl_double2 v2[4]; #endif #if defined( __CL_DOUBLE4__) __cl_double4 v4[2]; #endif #if defined( __CL_DOUBLE8__ ) __cl_double8 v8; #endif }cl_double8; typedef union { cl_double CL_ALIGNED(128) s[16]; #if __CL_HAS_ANON_STRUCT__ __CL_ANON_STRUCT__ struct{ cl_double x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; __CL_ANON_STRUCT__ struct{ cl_double s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; __CL_ANON_STRUCT__ struct{ cl_double8 lo, hi; }; #endif #if defined( __CL_DOUBLE2__) __cl_double2 v2[8]; #endif #if defined( __CL_DOUBLE4__) __cl_double4 v4[4]; #endif #if defined( __CL_DOUBLE8__ ) __cl_double8 v8[2]; #endif #if defined( __CL_DOUBLE16__ ) __cl_double16 v16; #endif }cl_double16; /* Macro to facilitate debugging * Usage: * Place CL_PROGRAM_STRING_DEBUG_INFO on the line before the first line of your source. * The first line ends with: CL_PROGRAM_STRING_DEBUG_INFO \" * Each line thereafter of OpenCL C source must end with: \n\ * The last line ends in "; * * Example: * * const char *my_program = CL_PROGRAM_STRING_DEBUG_INFO "\ * kernel void foo( int a, float * b ) \n\ * { \n\ * // my comment \n\ * *b[ get_global_id(0)] = a; \n\ * } \n\ * "; * * This should correctly set up the line, (column) and file information for your source * string so you can do source level debugging. */ #define __CL_STRINGIFY( _x ) # _x #define _CL_STRINGIFY( _x ) __CL_STRINGIFY( _x ) #define CL_PROGRAM_STRING_DEBUG_INFO "#line " _CL_STRINGIFY(__LINE__) " \"" __FILE__ "\" \n\n" #ifdef __cplusplus } #endif #if defined(_WIN32) && defined(_MSC_VER) && __CL_HAS_ANON_STRUCT__ #pragma warning( pop ) #endif #endif /* __CL_PLATFORM_H */ ocl-icd-2.3.3/khronos-headers/CL/cl_va_api_media_sharing_intel.h000066400000000000000000000147341477331540600246010ustar00rootroot00000000000000/******************************************************************************* * Copyright (c) 2008-2023 The Khronos Group Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. ******************************************************************************/ #ifndef OPENCL_CL_VA_API_MEDIA_SHARING_INTEL_H_ #define OPENCL_CL_VA_API_MEDIA_SHARING_INTEL_H_ /* ** This header is generated from the Khronos OpenCL XML API Registry. */ #include #include /* CL_NO_PROTOTYPES implies CL_NO_EXTENSION_PROTOTYPES: */ #if defined(CL_NO_PROTOTYPES) && !defined(CL_NO_EXTENSION_PROTOTYPES) #define CL_NO_EXTENSION_PROTOTYPES #endif /* CL_NO_EXTENSION_PROTOTYPES implies CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES and CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES: */ #if defined(CL_NO_EXTENSION_PROTOTYPES) && \ !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) #define CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES #endif #if defined(CL_NO_EXTENSION_PROTOTYPES) && \ !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) #define CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES #endif #ifdef __cplusplus extern "C" { #endif /*************************************************************** * cl_intel_sharing_format_query_va_api ***************************************************************/ #define cl_intel_sharing_format_query_va_api 1 #define CL_INTEL_SHARING_FORMAT_QUERY_VA_API_EXTENSION_NAME \ "cl_intel_sharing_format_query_va_api" /* when cl_intel_va_api_media_sharing is supported */ typedef cl_int (CL_API_CALL * clGetSupportedVA_APIMediaSurfaceFormatsINTEL_fn)( cl_context context, cl_mem_flags flags, cl_mem_object_type image_type, cl_uint plane, cl_uint num_entries, VAImageFormat* va_api_formats, cl_uint* num_surface_formats) ; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL clGetSupportedVA_APIMediaSurfaceFormatsINTEL( cl_context context, cl_mem_flags flags, cl_mem_object_type image_type, cl_uint plane, cl_uint num_entries, VAImageFormat* va_api_formats, cl_uint* num_surface_formats) ; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_intel_va_api_media_sharing ***************************************************************/ #define cl_intel_va_api_media_sharing 1 #define CL_INTEL_VA_API_MEDIA_SHARING_EXTENSION_NAME \ "cl_intel_va_api_media_sharing" typedef cl_uint cl_va_api_device_source_intel; typedef cl_uint cl_va_api_device_set_intel; /* Error codes */ #define CL_INVALID_VA_API_MEDIA_ADAPTER_INTEL -1098 #define CL_INVALID_VA_API_MEDIA_SURFACE_INTEL -1099 #define CL_VA_API_MEDIA_SURFACE_ALREADY_ACQUIRED_INTEL -1100 #define CL_VA_API_MEDIA_SURFACE_NOT_ACQUIRED_INTEL -1101 /* cl_va_api_device_source_intel */ #define CL_VA_API_DISPLAY_INTEL 0x4094 /* cl_va_api_device_set_intel */ #define CL_PREFERRED_DEVICES_FOR_VA_API_INTEL 0x4095 #define CL_ALL_DEVICES_FOR_VA_API_INTEL 0x4096 /* cl_context_info */ #define CL_CONTEXT_VA_API_DISPLAY_INTEL 0x4097 /* cl_mem_info */ #define CL_MEM_VA_API_MEDIA_SURFACE_INTEL 0x4098 /* cl_image_info */ #define CL_IMAGE_VA_API_PLANE_INTEL 0x4099 /* cl_command_type */ #define CL_COMMAND_ACQUIRE_VA_API_MEDIA_SURFACES_INTEL 0x409A #define CL_COMMAND_RELEASE_VA_API_MEDIA_SURFACES_INTEL 0x409B typedef cl_int (CL_API_CALL * clGetDeviceIDsFromVA_APIMediaAdapterINTEL_fn)( cl_platform_id platform, cl_va_api_device_source_intel media_adapter_type, void* media_adapter, cl_va_api_device_set_intel media_adapter_set, cl_uint num_entries, cl_device_id* devices, cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_2; typedef cl_mem (CL_API_CALL * clCreateFromVA_APIMediaSurfaceINTEL_fn)( cl_context context, cl_mem_flags flags, VASurfaceID* surface, cl_uint plane, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; typedef cl_int (CL_API_CALL * clEnqueueAcquireVA_APIMediaSurfacesINTEL_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_2; typedef cl_int (CL_API_CALL * clEnqueueReleaseVA_APIMediaSurfacesINTEL_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_2; #if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromVA_APIMediaAdapterINTEL( cl_platform_id platform, cl_va_api_device_source_intel media_adapter_type, void* media_adapter, cl_va_api_device_set_intel media_adapter_set, cl_uint num_entries, cl_device_id* devices, cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_2; extern CL_API_ENTRY cl_mem CL_API_CALL clCreateFromVA_APIMediaSurfaceINTEL( cl_context context, cl_mem_flags flags, VASurfaceID* surface, cl_uint plane, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireVA_APIMediaSurfacesINTEL( 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_2; extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseVA_APIMediaSurfacesINTEL( 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_2; #endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ #ifdef __cplusplus } #endif #endif /* OPENCL_CL_VA_API_MEDIA_SHARING_INTEL_H_ */ ocl-icd-2.3.3/khronos-headers/CL/cl_version.h000066400000000000000000000060651477331540600207600ustar00rootroot00000000000000/******************************************************************************* * Copyright (c) 2018-2020 The Khronos Group Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. ******************************************************************************/ #ifndef __CL_VERSION_H #define __CL_VERSION_H /* Detect which version to target */ #if !defined(CL_TARGET_OPENCL_VERSION) #pragma message("cl_version.h: CL_TARGET_OPENCL_VERSION is not defined. Defaulting to 300 (OpenCL 3.0)") #define CL_TARGET_OPENCL_VERSION 300 #endif #if CL_TARGET_OPENCL_VERSION != 100 && \ CL_TARGET_OPENCL_VERSION != 110 && \ CL_TARGET_OPENCL_VERSION != 120 && \ CL_TARGET_OPENCL_VERSION != 200 && \ CL_TARGET_OPENCL_VERSION != 210 && \ CL_TARGET_OPENCL_VERSION != 220 && \ CL_TARGET_OPENCL_VERSION != 300 #pragma message("cl_version: CL_TARGET_OPENCL_VERSION is not a valid value (100, 110, 120, 200, 210, 220, 300). Defaulting to 300 (OpenCL 3.0)") #undef CL_TARGET_OPENCL_VERSION #define CL_TARGET_OPENCL_VERSION 300 #endif /* OpenCL Version */ #if CL_TARGET_OPENCL_VERSION >= 300 && !defined(CL_VERSION_3_0) #define CL_VERSION_3_0 1 #endif #if CL_TARGET_OPENCL_VERSION >= 220 && !defined(CL_VERSION_2_2) #define CL_VERSION_2_2 1 #endif #if CL_TARGET_OPENCL_VERSION >= 210 && !defined(CL_VERSION_2_1) #define CL_VERSION_2_1 1 #endif #if CL_TARGET_OPENCL_VERSION >= 200 && !defined(CL_VERSION_2_0) #define CL_VERSION_2_0 1 #endif #if CL_TARGET_OPENCL_VERSION >= 120 && !defined(CL_VERSION_1_2) #define CL_VERSION_1_2 1 #endif #if CL_TARGET_OPENCL_VERSION >= 110 && !defined(CL_VERSION_1_1) #define CL_VERSION_1_1 1 #endif #if CL_TARGET_OPENCL_VERSION >= 100 && !defined(CL_VERSION_1_0) #define CL_VERSION_1_0 1 #endif /* Allow deprecated APIs for older OpenCL versions. */ #if CL_TARGET_OPENCL_VERSION <= 220 && !defined(CL_USE_DEPRECATED_OPENCL_2_2_APIS) #define CL_USE_DEPRECATED_OPENCL_2_2_APIS #endif #if CL_TARGET_OPENCL_VERSION <= 210 && !defined(CL_USE_DEPRECATED_OPENCL_2_1_APIS) #define CL_USE_DEPRECATED_OPENCL_2_1_APIS #endif #if CL_TARGET_OPENCL_VERSION <= 200 && !defined(CL_USE_DEPRECATED_OPENCL_2_0_APIS) #define CL_USE_DEPRECATED_OPENCL_2_0_APIS #endif #if CL_TARGET_OPENCL_VERSION <= 120 && !defined(CL_USE_DEPRECATED_OPENCL_1_2_APIS) #define CL_USE_DEPRECATED_OPENCL_1_2_APIS #endif #if CL_TARGET_OPENCL_VERSION <= 110 && !defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS) #define CL_USE_DEPRECATED_OPENCL_1_1_APIS #endif #if CL_TARGET_OPENCL_VERSION <= 100 && !defined(CL_USE_DEPRECATED_OPENCL_1_0_APIS) #define CL_USE_DEPRECATED_OPENCL_1_0_APIS #endif #endif /* __CL_VERSION_H */ ocl-icd-2.3.3/khronos-headers/CL/opencl.h000066400000000000000000000017121477331540600200670ustar00rootroot00000000000000/******************************************************************************* * Copyright (c) 2008-2021 The Khronos Group Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. ******************************************************************************/ #ifndef __OPENCL_H #define __OPENCL_H #ifdef __cplusplus extern "C" { #endif #include #include #include #ifdef __cplusplus } #endif #endif /* __OPENCL_H */ ocl-icd-2.3.3/khronos-headers/OpenCL000077700000000000000000000000001477331540600174162CLustar00rootroot00000000000000ocl-icd-2.3.3/libdummy_icd.c000066400000000000000000000205521477331540600156540ustar00rootroot00000000000000/** Copyright (c) 2012-2020, Brice Videau Copyright (c) 2012-2020, Vincent Danjean All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "ocl_icd_debug.h" #include "libdummy_icd.h" #include "libdummy_icd_gen.h" #include #include #include #define NUM_PLATFORMS 1 #if defined(__APPLE__) || defined(__MACOSX) #define SYMB(f) #else #define SYMB(f) \ typeof(INT##f) f __attribute__ ((alias ("INT" #f), visibility("default"))) #endif #pragma GCC visibility push(hidden) int debug_ocl_icd_mask; cl_uint const num_master_platforms = NUM_PLATFORMS; struct _cl_platform_id master_platforms[NUM_PLATFORMS] = { {&master_dispatch} }; static cl_int _GetPlatformIDs( cl_uint num_entries, cl_platform_id *platforms, cl_uint *num_platforms) { debug_trace(); if( platforms == NULL && num_platforms == NULL ) return CL_INVALID_VALUE; if( num_entries == 0 && platforms != NULL ) return CL_INVALID_VALUE; if( num_master_platforms == 0) return CL_PLATFORM_NOT_FOUND_KHR; if( num_platforms != NULL ){ debug(D_LOG, " asked num_platforms"); *num_platforms = num_master_platforms; } if( platforms != NULL ) { debug(D_LOG, " asked %i platforms", num_entries); cl_uint i; for( i=0; i<(num_master_platforms param_value_size ) return CL_INVALID_VALUE; memcpy(param_value, string_p, size_string); } if( param_value_size_ret != NULL ) *param_value_size_ret = size_string; return CL_SUCCESS; } SYMB(clGetPlatformInfo); CL_API_ENTRY cl_int CL_API_CALL INTclGetDeviceIDs(cl_platform_id pid /* platform */, cl_device_type ctype /* device_type */, cl_uint num /* num_entries */, cl_device_id * devid /* devices */, cl_uint * res /* num_devices */) CL_API_SUFFIX__VERSION_1_0 { if (ctype==0 && num==0 && devid==NULL && res==NULL) { printf("2 : "); } char* ENVNAME=NULL; if (res == NULL) { return CL_SUCCESS; } switch (ctype) { case CL_DEVICE_TYPE_GPU: ENVNAME="NB_GPU" ICD_SUFFIX; break; case CL_DEVICE_TYPE_CPU: ENVNAME="NB_CPU" ICD_SUFFIX; break; case CL_DEVICE_TYPE_ALL: ENVNAME="NB_ALL" ICD_SUFFIX; break; } if (ENVNAME==NULL) { *res=0; } else { char* strnb=getenv(ENVNAME); if (strnb) { *res=atoi(getenv(ENVNAME)); } else { *res=0; } } return CL_SUCCESS; } #pragma GCC visibility pop ocl-icd-2.3.3/libdummy_icd.h000066400000000000000000000026361477331540600156640ustar00rootroot00000000000000/** Copyright (c) 2012, Brice Videau Copyright (c) 2012, Vincent Danjean All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include ocl-icd-2.3.3/m4/000077500000000000000000000000001477331540600133635ustar00rootroot00000000000000ocl-icd-2.3.3/m4/amx_silent_rules.m4000066400000000000000000000041131477331540600172010ustar00rootroot00000000000000# # SYNOPSIS # # AMX_SILENT_RULES([action-if-exists], [action-if-not-exists]) # # DESCRIPTION # # These macro calls AM_SILENT_RULES and set AM_DEFAULT_VERBOSITY # if the AM_SILENT_RULES exists (ie automake >= 1.11) # # LAST MODIFICATION # # 2010-01-13 # # COPYLEFT # # Copyright (c) 2010 Vincent Danjean # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License as # published by the Free Software Foundation; either version 2 of the # License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA # 02111-1307, USA. # # As a special exception, the respective Autoconf Macro's copyright # owner gives unlimited permission to copy, distribute and modify the # configure scripts that are the output of Autoconf when processing # the Macro. You need not follow the terms of the GNU General Public # License when using or distributing such scripts, even though # portions of the text of the Macro appear in them. The GNU General # Public License (GPL) does govern all other use of the material that # constitutes the Autoconf Macro. # # This special exception to the GPL applies to versions of the # Autoconf Macro released by the Autoconf Macro Archive. When you # make and distribute a modified version of the Autoconf Macro, you # may extend this special exception to the GPL to apply to your # modified version as well. AC_DEFUN([AMX_SILENT_RULES], [ m4_ifdef([AM_SILENT_RULES], [ AM_SILENT_RULES $1 ], [ AC_MSG_NOTICE([Not using silent Makefile rules as automake 1.11 is required for this]) $2 ]) ])dnl AMX_SILENT_RULES ocl-icd-2.3.3/m4/ax_check_compiler_flags.m4000066400000000000000000000062441477331540600204460ustar00rootroot00000000000000##### http://autoconf-archive.cryp.to/ax_check_compiler_flags.html # # SYNOPSIS # # AX_CHECK_COMPILER_FLAGS(FLAGS, [ACTION-SUCCESS], [ACTION-FAILURE]) # # DESCRIPTION # # Check whether the given compiler FLAGS work with the current # language's compiler, or whether they give an error. (Warnings, # however, are ignored.) # # ACTION-SUCCESS/ACTION-FAILURE are shell commands to execute on # success/failure. # # LAST MODIFICATION # # 2005-05-30 # # COPYLEFT # # Copyright (c) 2005 Steven G. Johnson # Copyright (c) 2005 Matteo Frigo # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License as # published by the Free Software Foundation; either version 2 of the # License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA # 02111-1307, USA. # # As a special exception, the respective Autoconf Macro's copyright # owner gives unlimited permission to copy, distribute and modify the # configure scripts that are the output of Autoconf when processing # the Macro. You need not follow the terms of the GNU General Public # License when using or distributing such scripts, even though # portions of the text of the Macro appear in them. The GNU General # Public License (GPL) does govern all other use of the material that # constitutes the Autoconf Macro. # # This special exception to the GPL applies to versions of the # Autoconf Macro released by the Autoconf Macro Archive. When you # make and distribute a modified version of the Autoconf Macro, you # may extend this special exception to the GPL to apply to your # modified version as well. AC_DEFUN([AX_CHECK_COMPILER_FLAGS], [AC_PREREQ(2.59) dnl for _AC_LANG_PREFIX AC_MSG_CHECKING([whether _AC_LANG compiler accepts $1]) dnl Some hackery here since AC_CACHE_VAL can't handle a non-literal varname: AS_LITERAL_IF([$1], [AC_CACHE_VAL(AS_TR_SH(ax_cv_[]_AC_LANG_ABBREV[]_flags_$1), [ ax_save_FLAGS=$[]_AC_LANG_PREFIX[]FLAGS _AC_LANG_PREFIX[]FLAGS="$1" AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], AS_TR_SH(ax_cv_[]_AC_LANG_ABBREV[]_flags_$1)=yes, AS_TR_SH(ax_cv_[]_AC_LANG_ABBREV[]_flags_$1)=no) _AC_LANG_PREFIX[]FLAGS=$ax_save_FLAGS])], [ax_save_FLAGS=$[]_AC_LANG_PREFIX[]FLAGS _AC_LANG_PREFIX[]FLAGS="$1" AC_COMPILE_IFELSE([AC_LANG_PROGRAM()], eval AS_TR_SH(ax_cv_[]_AC_LANG_ABBREV[]_flags_$1)=yes, eval AS_TR_SH(ax_cv_[]_AC_LANG_ABBREV[]_flags_$1)=no) _AC_LANG_PREFIX[]FLAGS=$ax_save_FLAGS]) eval ax_check_compiler_flags=$AS_TR_SH(ax_cv_[]_AC_LANG_ABBREV[]_flags_$1) AC_MSG_RESULT($ax_check_compiler_flags) if test "x$ax_check_compiler_flags" = xyes; then m4_default([$2], :) else m4_default([$3], :) fi ])dnl AX_CHECK_COMPILER_FLAGS ocl-icd-2.3.3/m4/ax_pthread.m4000066400000000000000000000304401477331540600157450ustar00rootroot00000000000000# =========================================================================== # http://www.gnu.org/software/autoconf-archive/ax_pthread.html # =========================================================================== # # SYNOPSIS # # AX_PTHREAD([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]]) # # DESCRIPTION # # This macro figures out how to build C programs using POSIX threads. It # sets the PTHREAD_LIBS output variable to the threads library and linker # flags, and the PTHREAD_CFLAGS output variable to any special C compiler # flags that are needed. (The user can also force certain compiler # flags/libs to be tested by setting these environment variables.) # # Also sets PTHREAD_CC to any special C compiler that is needed for # multi-threaded programs (defaults to the value of CC otherwise). (This # is necessary on AIX to use the special cc_r compiler alias.) # # NOTE: You are assumed to not only compile your program with these flags, # but also link it with them as well. e.g. you should link with # $PTHREAD_CC $CFLAGS $PTHREAD_CFLAGS $LDFLAGS ... $PTHREAD_LIBS $LIBS # # If you are only building threads programs, you may wish to use these # variables in your default LIBS, CFLAGS, and CC: # # LIBS="$PTHREAD_LIBS $LIBS" # CFLAGS="$CFLAGS $PTHREAD_CFLAGS" # CC="$PTHREAD_CC" # # In addition, if the PTHREAD_CREATE_JOINABLE thread-attribute constant # has a nonstandard name, defines PTHREAD_CREATE_JOINABLE to that name # (e.g. PTHREAD_CREATE_UNDETACHED on AIX). # # Also HAVE_PTHREAD_PRIO_INHERIT is defined if pthread is found and the # PTHREAD_PRIO_INHERIT symbol is defined when compiling with # PTHREAD_CFLAGS. # # ACTION-IF-FOUND is a list of shell commands to run if a threads library # is found, and ACTION-IF-NOT-FOUND is a list of commands to run it if it # is not found. If ACTION-IF-FOUND is not specified, the default action # will define HAVE_PTHREAD. # # Please let the authors know if this macro fails on any platform, or if # you have any other suggestions or comments. This macro was based on work # by SGJ on autoconf scripts for FFTW (http://www.fftw.org/) (with help # from M. Frigo), as well as ac_pthread and hb_pthread macros posted by # Alejandro Forero Cuervo to the autoconf macro repository. We are also # grateful for the helpful feedback of numerous users. # # Updated for Autoconf 2.68 by Daniel Richard G. # # LICENSE # # Copyright (c) 2008 Steven G. Johnson # Copyright (c) 2011 Daniel Richard G. # # This program is free software: you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by the # Free Software Foundation, either version 3 of the License, or (at your # option) any later version. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General # Public License for more details. # # You should have received a copy of the GNU General Public License along # with this program. If not, see . # # As a special exception, the respective Autoconf Macro's copyright owner # gives unlimited permission to copy, distribute and modify the configure # scripts that are the output of Autoconf when processing the Macro. You # need not follow the terms of the GNU General Public License when using # or distributing such scripts, even though portions of the text of the # Macro appear in them. The GNU General Public License (GPL) does govern # all other use of the material that constitutes the Autoconf Macro. # # This special exception to the GPL applies to versions of the Autoconf # Macro released by the Autoconf Archive. When you make and distribute a # modified version of the Autoconf Macro, you may extend this special # exception to the GPL to apply to your modified version as well. #serial 17 AU_ALIAS([ACX_PTHREAD], [AX_PTHREAD]) AC_DEFUN([AX_PTHREAD], [ AC_REQUIRE([AC_CANONICAL_HOST]) AC_LANG_PUSH([C]) ax_pthread_ok=no # We used to check for pthread.h first, but this fails if pthread.h # requires special compiler flags (e.g. on True64 or Sequent). # It gets checked for in the link test anyway. # First of all, check if the user has set any of the PTHREAD_LIBS, # etcetera environment variables, and if threads linking works using # them: if test x"$PTHREAD_LIBS$PTHREAD_CFLAGS" != x; then save_CFLAGS="$CFLAGS" CFLAGS="$CFLAGS $PTHREAD_CFLAGS" save_LIBS="$LIBS" LIBS="$PTHREAD_LIBS $LIBS" AC_MSG_CHECKING([for pthread_join in LIBS=$PTHREAD_LIBS with CFLAGS=$PTHREAD_CFLAGS]) AC_TRY_LINK_FUNC(pthread_join, ax_pthread_ok=yes) AC_MSG_RESULT($ax_pthread_ok) if test x"$ax_pthread_ok" = xno; then PTHREAD_LIBS="" PTHREAD_CFLAGS="" fi LIBS="$save_LIBS" CFLAGS="$save_CFLAGS" fi # We must check for the threads library under a number of different # names; the ordering is very important because some systems # (e.g. DEC) have both -lpthread and -lpthreads, where one of the # libraries is broken (non-POSIX). # Create a list of thread flags to try. Items starting with a "-" are # C compiler flags, and other items are library names, except for "none" # which indicates that we try without any flags at all, and "pthread-config" # which is a program returning the flags for the Pth emulation library. ax_pthread_flags="pthreads none -Kthread -kthread lthread -pthread -pthreads -mthreads pthread --thread-safe -mt pthread-config" # The ordering *is* (sometimes) important. Some notes on the # individual items follow: # pthreads: AIX (must check this before -lpthread) # none: in case threads are in libc; should be tried before -Kthread and # other compiler flags to prevent continual compiler warnings # -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h) # -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able) # lthread: LinuxThreads port on FreeBSD (also preferred to -pthread) # -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads) # -pthreads: Solaris/gcc # -mthreads: Mingw32/gcc, Lynx/gcc # -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it # doesn't hurt to check since this sometimes defines pthreads too; # also defines -D_REENTRANT) # ... -mt is also the pthreads flag for HP/aCC # pthread: Linux, etcetera # --thread-safe: KAI C++ # pthread-config: use pthread-config program (for GNU Pth library) case "${host_cpu}-${host_os}" in *solaris*) # On Solaris (at least, for some versions), libc contains stubbed # (non-functional) versions of the pthreads routines, so link-based # tests will erroneously succeed. (We need to link with -pthreads/-mt/ # -lpthread.) (The stubs are missing pthread_cleanup_push, or rather # a function called by this macro, so we could check for that, but # who knows whether they'll stub that too in a future libc.) So, # we'll just look for -pthreads and -lpthread first: ax_pthread_flags="-pthreads pthread -mt -pthread $ax_pthread_flags" ;; *-darwin*) ax_pthread_flags="-pthread $ax_pthread_flags" ;; esac if test x"$ax_pthread_ok" = xno; then for flag in $ax_pthread_flags; do case $flag in none) AC_MSG_CHECKING([whether pthreads work without any flags]) ;; -*) AC_MSG_CHECKING([whether pthreads work with $flag]) PTHREAD_CFLAGS="$flag" ;; pthread-config) AC_CHECK_PROG(ax_pthread_config, pthread-config, yes, no) if test x"$ax_pthread_config" = xno; then continue; fi PTHREAD_CFLAGS="`pthread-config --cflags`" PTHREAD_LIBS="`pthread-config --ldflags` `pthread-config --libs`" ;; *) AC_MSG_CHECKING([for the pthreads library -l$flag]) PTHREAD_LIBS="-l$flag" ;; esac save_LIBS="$LIBS" save_CFLAGS="$CFLAGS" LIBS="$PTHREAD_LIBS $LIBS" CFLAGS="$CFLAGS $PTHREAD_CFLAGS" # Check for various functions. We must include pthread.h, # since some functions may be macros. (On the Sequent, we # need a special flag -Kthread to make this header compile.) # We check for pthread_join because it is in -lpthread on IRIX # while pthread_create is in libc. We check for pthread_attr_init # due to DEC craziness with -lpthreads. We check for # pthread_cleanup_push because it is one of the few pthread # functions on Solaris that doesn't have a non-functional libc stub. # We try pthread_create on general principles. AC_LINK_IFELSE([AC_LANG_PROGRAM([#include static void routine(void *a) { a = 0; } static void *start_routine(void *a) { return a; }], [pthread_t th; pthread_attr_t attr; pthread_create(&th, 0, start_routine, 0); pthread_join(th, 0); pthread_attr_init(&attr); pthread_cleanup_push(routine, 0); pthread_cleanup_pop(0) /* ; */])], [ax_pthread_ok=yes], []) LIBS="$save_LIBS" CFLAGS="$save_CFLAGS" AC_MSG_RESULT($ax_pthread_ok) if test "x$ax_pthread_ok" = xyes; then break; fi PTHREAD_LIBS="" PTHREAD_CFLAGS="" done fi # Various other checks: if test "x$ax_pthread_ok" = xyes; then save_LIBS="$LIBS" LIBS="$PTHREAD_LIBS $LIBS" save_CFLAGS="$CFLAGS" CFLAGS="$CFLAGS $PTHREAD_CFLAGS" # Detect AIX lossage: JOINABLE attribute is called UNDETACHED. AC_MSG_CHECKING([for joinable pthread attribute]) attr_name=unknown for attr in PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_UNDETACHED; do AC_LINK_IFELSE([AC_LANG_PROGRAM([#include ], [int attr = $attr; return attr /* ; */])], [attr_name=$attr; break], []) done AC_MSG_RESULT($attr_name) if test "$attr_name" != PTHREAD_CREATE_JOINABLE; then AC_DEFINE_UNQUOTED(PTHREAD_CREATE_JOINABLE, $attr_name, [Define to necessary symbol if this constant uses a non-standard name on your system.]) fi AC_MSG_CHECKING([if more special flags are required for pthreads]) flag=no case "${host_cpu}-${host_os}" in *-aix* | *-freebsd* | *-darwin*) flag="-D_THREAD_SAFE";; *-osf* | *-hpux*) flag="-D_REENTRANT";; *solaris*) if test "$GCC" = "yes"; then flag="-D_REENTRANT" else flag="-mt -D_REENTRANT" fi ;; esac AC_MSG_RESULT(${flag}) if test "x$flag" != xno; then PTHREAD_CFLAGS="$flag $PTHREAD_CFLAGS" fi AC_CACHE_CHECK([for PTHREAD_PRIO_INHERIT], ax_cv_PTHREAD_PRIO_INHERIT, [ AC_LINK_IFELSE([ AC_LANG_PROGRAM([[#include ]], [[int i = PTHREAD_PRIO_INHERIT;]])], [ax_cv_PTHREAD_PRIO_INHERIT=yes], [ax_cv_PTHREAD_PRIO_INHERIT=no]) ]) AS_IF([test "x$ax_cv_PTHREAD_PRIO_INHERIT" = "xyes"], AC_DEFINE([HAVE_PTHREAD_PRIO_INHERIT], 1, [Have PTHREAD_PRIO_INHERIT.])) LIBS="$save_LIBS" CFLAGS="$save_CFLAGS" # More AIX lossage: must compile with xlc_r or cc_r if test x"$GCC" != xyes; then AC_CHECK_PROGS(PTHREAD_CC, xlc_r cc_r, ${CC}) else PTHREAD_CC=$CC fi else PTHREAD_CC="$CC" fi AC_SUBST(PTHREAD_LIBS) AC_SUBST(PTHREAD_CFLAGS) AC_SUBST(PTHREAD_CC) # Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND: if test x"$ax_pthread_ok" = xyes; then ifelse([$1],,AC_DEFINE(HAVE_PTHREAD,1,[Define if you have POSIX threads libraries and header files.]),[$1]) : else ax_pthread_ok=no $2 fi AC_LANG_POP ])dnl AX_PTHREAD ocl-icd-2.3.3/ocl-icd.pc.in000066400000000000000000000004061477331540600153060ustar00rootroot00000000000000prefix=@prefix@ exec_prefix=@exec_prefix@ libdir=@libdir@ includedir=@includedir@ Name: ocl-icd Description: Open Computing Language generic Installable Client Driver support Requires: OpenCL-Headers Version: @VERSION@ Libs: -L${libdir} Cflags: -I${includedir} ocl-icd-2.3.3/ocl_icd_debug.h000066400000000000000000000073561477331540600157710ustar00rootroot00000000000000/** Copyright (c) 2012, Vincent Danjean All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #ifndef OCL_ICD_LOADER_DEBUG_H #define OCL_ICD_LOADER_DEBUG_H #ifdef DEBUG_OCL_ICD_PROVIDE_DUMP_FIELD # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wcpp" # define CL_USE_DEPRECATED_OPENCL_1_0_APIS # define CL_USE_DEPRECATED_OPENCL_1_1_APIS # define CL_USE_DEPRECATED_OPENCL_1_2_APIS # define CL_USE_DEPRECATED_OPENCL_2_0_APIS # define CL_USE_DEPRECATED_OPENCL_2_1_APIS # define CL_USE_DEPRECATED_OPENCL_2_2_APIS # define CL_TARGET_OPENCL_VERSION 300 #else # define CL_TARGET_OPENCL_VERSION 300 #endif #include #ifdef DEBUG_OCL_ICD_PROVIDE_DUMP_FIELD # pragma GCC diagnostic pop #endif #pragma GCC visibility push(hidden) #include "config.h" #define D_ALWAYS 0 #define D_WARN 1 #define D_LOG 2 #define D_TRACE 4 #define D_DUMP 8 #ifdef DEBUG_OCL_ICD # pragma GCC visibility push(default) # include # include # pragma GCC visibility pop extern int debug_ocl_icd_mask; # define debug(mask, fmt, ...) do {\ if (((mask)==D_ALWAYS) || (debug_ocl_icd_mask & (mask))) { \ fprintf(stderr, "ocl-icd(%s:%i): %s: " fmt "\n", __FILE__, __LINE__, __func__, ##__VA_ARGS__); \ } \ } while(0) # define RETURN(val) do { \ __typeof__(val) ret=(val); \ debug(D_TRACE, "return: %ld/0x%lx", (long)ret, (long)ret); \ return ret; \ } while(0) # define RETURN_STR(val) do { \ char* _ret=(char*)(val); \ debug(D_TRACE, "return: %s", _ret); \ return _ret; \ } while(0) # ifdef DEBUG_OCL_ICD_PROVIDE_DUMP_FIELD # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wdeprecated-declarations" typedef __typeof__(clGetExtensionFunctionAddress) *clGEFA_t; # pragma GCC diagnostic pop void dump_platform(clGEFA_t f, cl_platform_id pid); # endif static inline void debug_init(void) { static int done=0; if (!done) { char *debug=getenv("OCL_ICD_DEBUG"); if (debug) { debug_ocl_icd_mask=atoi(debug); if (*debug == 0) debug_ocl_icd_mask=1; } done=1; } } # define dump_field(pid, f, name) \ debug(D_ALWAYS, "%40s=%p [%p/%p]", #name, pid->dispatch->name, f(#name), ((long)(pid->dispatch->clGetExtensionFunctionAddressForPlatform)>10)?pid->dispatch->clGetExtensionFunctionAddressForPlatform(pid, #name):NULL) #else # define debug(...) (void)0 # define RETURN(val) return (val) # define RETURN_STR(val) return (val) # define debug_init() (void)0 #endif #define debug_trace() debug(D_TRACE, "Entering") #pragma GCC visibility pop #endif ocl-icd-2.3.3/ocl_icd_loader.c000066400000000000000000001301671477331540600161410ustar00rootroot00000000000000/** Copyright (c) 2012-2020, Brice Videau Copyright (c) 2012-2020, Vincent Danjean All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include #include #include #include #include #include #include #include #include #include "config.h" #ifdef USE_PTHREAD # include #endif #pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wcpp" # define CL_USE_DEPRECATED_OPENCL_1_0_APIS # define CL_USE_DEPRECATED_OPENCL_1_1_APIS # define CL_USE_DEPRECATED_OPENCL_1_2_APIS # define CL_USE_DEPRECATED_OPENCL_2_0_APIS # define CL_USE_DEPRECATED_OPENCL_2_1_APIS # define CL_USE_DEPRECATED_OPENCL_2_2_APIS # define CL_TARGET_OPENCL_VERSION 300 # include #pragma GCC diagnostic pop #pragma GCC visibility push(hidden) #include "ocl_icd_loader.h" #define DEBUG_OCL_ICD_PROVIDE_DUMP_FIELD #include "ocl_icd_debug.h" int debug_ocl_icd_mask=0; static inline void dump_vendor_icd(const char* info, const struct vendor_icd *v) { debug(D_DUMP, "%s %p={ num=%i, handle=%p, f=%p}\n", info, v, v->num_platforms, v->dl_handle, v->ext_fn_ptr); } __attribute__((visibility("hidden"))) struct layer_icd *_first_layer=NULL; struct vendor_icd *_icds=NULL; struct platform_icd *_picds=NULL; static cl_uint _num_icds = 0; cl_uint _num_picds = 0; #ifdef DEBUG_OCL_ICD # define _clS(x) [-x] = #x # define MAX_CL_ERRORS (-CL_INVALID_DEVICE_PARTITION_COUNT) static char const * const clErrorStr[MAX_CL_ERRORS+1] = { _clS(CL_SUCCESS), _clS(CL_DEVICE_NOT_FOUND), _clS(CL_DEVICE_NOT_AVAILABLE), _clS(CL_COMPILER_NOT_AVAILABLE), _clS(CL_MEM_OBJECT_ALLOCATION_FAILURE), _clS(CL_OUT_OF_RESOURCES), _clS(CL_OUT_OF_HOST_MEMORY), _clS(CL_PROFILING_INFO_NOT_AVAILABLE), _clS(CL_MEM_COPY_OVERLAP), _clS(CL_IMAGE_FORMAT_MISMATCH), _clS(CL_IMAGE_FORMAT_NOT_SUPPORTED), _clS(CL_BUILD_PROGRAM_FAILURE), _clS(CL_MAP_FAILURE), _clS(CL_MISALIGNED_SUB_BUFFER_OFFSET), _clS(CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST), _clS(CL_COMPILE_PROGRAM_FAILURE), _clS(CL_LINKER_NOT_AVAILABLE), _clS(CL_LINK_PROGRAM_FAILURE), _clS(CL_DEVICE_PARTITION_FAILED), _clS(CL_KERNEL_ARG_INFO_NOT_AVAILABLE), _clS(CL_INVALID_VALUE), _clS(CL_INVALID_DEVICE_TYPE), _clS(CL_INVALID_PLATFORM), _clS(CL_INVALID_DEVICE), _clS(CL_INVALID_CONTEXT), _clS(CL_INVALID_QUEUE_PROPERTIES), _clS(CL_INVALID_COMMAND_QUEUE), _clS(CL_INVALID_HOST_PTR), _clS(CL_INVALID_MEM_OBJECT), _clS(CL_INVALID_IMAGE_FORMAT_DESCRIPTOR), _clS(CL_INVALID_IMAGE_SIZE), _clS(CL_INVALID_SAMPLER), _clS(CL_INVALID_BINARY), _clS(CL_INVALID_BUILD_OPTIONS), _clS(CL_INVALID_PROGRAM), _clS(CL_INVALID_PROGRAM_EXECUTABLE), _clS(CL_INVALID_KERNEL_NAME), _clS(CL_INVALID_KERNEL_DEFINITION), _clS(CL_INVALID_KERNEL), _clS(CL_INVALID_ARG_INDEX), _clS(CL_INVALID_ARG_VALUE), _clS(CL_INVALID_ARG_SIZE), _clS(CL_INVALID_KERNEL_ARGS), _clS(CL_INVALID_WORK_DIMENSION), _clS(CL_INVALID_WORK_GROUP_SIZE), _clS(CL_INVALID_WORK_ITEM_SIZE), _clS(CL_INVALID_GLOBAL_OFFSET), _clS(CL_INVALID_EVENT_WAIT_LIST), _clS(CL_INVALID_EVENT), _clS(CL_INVALID_OPERATION), _clS(CL_INVALID_GL_OBJECT), _clS(CL_INVALID_BUFFER_SIZE), _clS(CL_INVALID_MIP_LEVEL), _clS(CL_INVALID_GLOBAL_WORK_SIZE), _clS(CL_INVALID_PROPERTY), _clS(CL_INVALID_IMAGE_DESCRIPTOR), _clS(CL_INVALID_COMPILER_OPTIONS), _clS(CL_INVALID_LINKER_OPTIONS), _clS(CL_INVALID_DEVICE_PARTITION_COUNT) }; #undef _clS #endif static char* _clerror2string (cl_int error) __attribute__((unused)); static char* _clerror2string (cl_int error) { #ifdef DEBUG_OCL_ICD if (-error > MAX_CL_ERRORS || error > 0) { debug(D_WARN, "Unknown error code %d", error); RETURN_STR("OpenCL Error"); } const char *ret=clErrorStr[-error]; if (ret == NULL) { debug(D_WARN, "Unknown error code %d", error); RETURN_STR("OpenCL Error"); } RETURN_STR(ret); #else static char number[15]; if (error==0) { RETURN_STR("CL_SUCCESS"); } snprintf(number, 15, "%i", error); RETURN_STR(number); #endif } static inline int _string_end_with(const char* str, const char* suffix) { size_t len = strlen(str); size_t len_suff = strlen(suffix); if (len < len_suff + 1 || strcmp(str + len - len_suff, suffix) != 0) { return 0; } return 1; } #define ICD_EXTENSION ".icd" #define LAY_EXTENSION ".lay" static inline int _string_end_with_icd(const char* str) { return _string_end_with(str, ICD_EXTENSION); } static inline int _string_end_with_lay(const char* str) { return _string_end_with(str, LAY_EXTENSION); } static inline int _string_with_slash(const char* str) { return strchr(str, '/') != NULL; } static inline unsigned int _find_num_suffix_match(DIR *dir, const char* suffix) { unsigned int num_matches = 0; struct dirent *ent; while( (ent=readdir(dir)) != NULL ){ if (_string_end_with(ent->d_name, suffix)) { num_matches++; } } rewinddir(dir); return num_matches; } static inline unsigned int _find_num_icds(DIR *dir) { unsigned int num_icds = _find_num_suffix_match(dir, ICD_EXTENSION); RETURN(num_icds); } static inline unsigned int _find_num_lays(DIR *dir) { unsigned int num_lays = _find_num_suffix_match(dir, LAY_EXTENSION); RETURN(num_lays); } static int compare_path(const void *a, const void *b) { return strcoll(*(const char **)a, *(const char **)b); } static inline unsigned int _load_icd(int num_icds, const char* lib_path) { unsigned int ret=0; debug(D_LOG, "Loading ICD '%s'", lib_path); _icds[num_icds].dl_handle = dlopen(lib_path, RTLD_LAZY|RTLD_LOCAL);//|RTLD_DEEPBIND); if(_icds[num_icds].dl_handle != NULL) { debug(D_LOG, "ICD[%i] loaded", num_icds); ret=1; } else { debug(D_WARN, "error while dlopening the IDL: '%s',\n => skipping ICD", dlerror()); } return ret; } static inline unsigned int _open_driver(unsigned int num_icds, const char*dir_path, const char*file_path) { char * lib_path; char * err; unsigned int lib_path_length; if (dir_path != NULL) { lib_path_length = strlen(dir_path) + strlen(file_path) + 2; lib_path = malloc(lib_path_length*sizeof(char)); sprintf(lib_path,"%s/%s", dir_path, file_path); } else { lib_path_length = strlen(file_path) + 1; lib_path = malloc(lib_path_length*sizeof(char)); sprintf(lib_path,"%s", file_path); } debug(D_LOG, "Considering file '%s'", lib_path); FILE *f = fopen(lib_path,"r"); free(lib_path); if (f==NULL) { RETURN(num_icds); } fseek(f, 0, SEEK_END); lib_path_length = ftell(f)+1; fseek(f, 0, SEEK_SET); if(lib_path_length == 1) { debug(D_WARN, "File contents too short, skipping ICD"); fclose(f); RETURN(num_icds); } lib_path = malloc(lib_path_length*sizeof(char)); err = fgets(lib_path, lib_path_length, f); fclose(f); if( err == NULL ) { free(lib_path); debug(D_WARN, "Error while loading file contents, skipping ICD"); RETURN(num_icds); } lib_path_length = strnlen(lib_path, lib_path_length); if( lib_path[lib_path_length-1] == '\n' ) lib_path[lib_path_length-1] = '\0'; num_icds += _load_icd(num_icds, lib_path); free(lib_path); RETURN(num_icds); } static inline unsigned int _open_drivers(DIR *dir, const char* dir_path) { unsigned int num_icds = 0; struct dirent *ent; while( (ent=readdir(dir)) != NULL ){ if(! _string_end_with_icd(ent->d_name)) { continue; } num_icds = _open_driver(num_icds, dir_path, ent->d_name); } RETURN(num_icds); } static void* _get_function_addr(void* dlh, clGetExtensionFunctionAddress_fn fn, const char*name) { void *addr1; debug(D_LOG,"Looking for function %s",name); addr1=dlsym(dlh, name); if (addr1 == NULL) { debug(D_WARN, "Missing global symbol '%s' in ICD, should be skipped", name); } void* addr2=NULL; if (fn) { addr2=(*fn)(name); if (addr2 == NULL) { debug(D_WARN, "Missing function '%s' in ICD, should be skipped", name); } #ifdef DEBUG_OCL_ICD if (addr1 && addr2 && addr1!=addr2) { debug(D_WARN, "Function and symbol '%s' have different addresses (%p != %p)!", name, addr2, addr1); } #endif } if (!addr2) addr2=addr1; RETURN(addr2); } static int _allocate_platforms(int req) { static cl_uint allocated=0; debug(D_LOG,"Requesting allocation for %d platforms",req); if (allocated - _num_picds < req) { if (allocated==0) { _picds=(struct platform_icd*)malloc(req*sizeof(struct platform_icd)); } else { req = req - (allocated - _num_picds); _picds=(struct platform_icd*)realloc(_picds, (allocated+req)*sizeof(struct platform_icd)); } allocated += req; } RETURN(allocated - _num_picds); } static char* _malloc_clGetPlatformInfo(clGetPlatformInfo_fn plt_info_ptr, cl_platform_id pid, cl_platform_info cname, char* sname) { cl_int error; size_t param_value_size_ret; error = plt_info_ptr(pid, cname, 0, NULL, ¶m_value_size_ret); if (error != CL_SUCCESS) { debug(D_WARN, "Error %s while requesting %s in platform %p", _clerror2string(error), sname, pid); return NULL; } char *param_value = (char *)malloc(sizeof(char)*param_value_size_ret); if (param_value == NULL) { debug(D_WARN, "Error in malloc while requesting %s in platform %p", sname, pid); return NULL; } error = plt_info_ptr(pid, cname, param_value_size_ret, param_value, NULL); if (error != CL_SUCCESS){ free(param_value); debug(D_WARN, "Error %s while requesting %s in platform %p", _clerror2string(error), sname, pid); return NULL; } RETURN_STR(param_value); } static void _count_devices(struct platform_icd *p) { cl_int error; /* Ensure they are 0 in case of errors */ p->ngpus = p->ncpus = p->ndevs = 0; error = KHR_ICD2_DISPATCH(p->pid)->clGetDeviceIDs(p->pid, CL_DEVICE_TYPE_GPU, 0, NULL, &(p->ngpus)); if (error != CL_SUCCESS && error != CL_DEVICE_NOT_FOUND){ debug(D_WARN, "Error %s while counting GPU devices in platform %p", _clerror2string(error), p->pid); } error = KHR_ICD2_DISPATCH(p->pid)->clGetDeviceIDs(p->pid, CL_DEVICE_TYPE_CPU, 0, NULL, &(p->ncpus)); if (error != CL_SUCCESS && error != CL_DEVICE_NOT_FOUND){ debug(D_WARN, "Error %s while counting CPU devices in platform %p", _clerror2string(error), p->pid); } error = KHR_ICD2_DISPATCH(p->pid)->clGetDeviceIDs(p->pid, CL_DEVICE_TYPE_ALL, 0, NULL, &(p->ndevs)); if (error != CL_SUCCESS && error != CL_DEVICE_NOT_FOUND){ debug(D_WARN, "Error %s while counting ALL devices in platform %p", _clerror2string(error), p->pid); } } static int _cmp_platforms(const void *_a, const void *_b) { const struct platform_icd *a=(const struct platform_icd *)_a; const struct platform_icd *b=(const struct platform_icd *)_b; /* sort first platforms handling max gpu */ if (a->ngpus > b->ngpus) return -1; if (a->ngpus < b->ngpus) return 1; /* sort next platforms handling max cpu */ if (a->ncpus > b->ncpus) return -1; if (a->ncpus < b->ncpus) return 1; /* sort then platforms handling max devices */ if (a->ndevs > b->ndevs) return -1; if (a->ndevs < b->ndevs) return 1; /* else consider platforms equal */ return 0; } static void _sort_platforms(struct platform_icd *picds, int npicds) { debug(D_WARN, "Nb platefroms: %i", npicds); if (npicds > 1) { char* ocl_sort=getenv("OCL_ICD_PLATFORM_SORT"); if (ocl_sort!=NULL && !strcmp(ocl_sort, "none")) { debug(D_LOG, "Platform not sorted"); } else { if (ocl_sort!=NULL && strcmp(ocl_sort, "devices")) { debug(D_WARN, "Unknown platform sort algorithm requested: %s", ocl_sort); debug(D_WARN, "Switching do the 'devices' algorithm"); } int i; debug(D_LOG, "Platform sorted by GPU, CPU, DEV"); for (i=0; iext_fn_ptr = _get_function_addr(dlh, NULL, "clGetExtensionFunctionAddress"); clIcdGetPlatformIDsKHR_fn plt_fn_ptr = _get_function_addr(dlh, picd->ext_fn_ptr, "clIcdGetPlatformIDsKHR"); if( picd->ext_fn_ptr == NULL || plt_fn_ptr == NULL) { debug(D_WARN, "Missing symbols in ICD, skipping it"); continue; } clGetPlatformInfo_fn plt_info_ptr = _get_function_addr(dlh, picd->ext_fn_ptr, "clGetPlatformInfo"); if (plt_info_ptr == NULL) { switch (_assume_ICD_extension()) { case ASSUME_ICD_EXTENSION_NO: debug(D_WARN, "Missing 'clGetPlatformInfo' symbol in ICD, skipping it (use OCL_ICD_ASSUME_ICD_EXTENSION to ignore this check)"); continue; case ASSUME_ICD_EXTENSION_YES: debug(D_LOG, "Missing 'clGetPlatformInfo' symbol in ICD, but still continuing due to OCL_ICD_ASSUME_ICD_EXTENSION"); /* Fall through */ case ASSUME_ICD_EXTENSION_YES_AND_QUIET: /* Assuming an ICD extension, so we will try to * find the ICD specific version of * clGetPlatformInfo before knowing for sure that * the cl_khr_icd is really present */ break; default: debug(D_ALWAYS, "Internal error in _assume_ICD_extension, please report"); break; } } cl_uint num_platforms=0; cl_int error; error = (*plt_fn_ptr)(0, NULL, &num_platforms); if( error != CL_SUCCESS || num_platforms == 0) { debug(D_LOG, "No platform in ICD, skipping it"); continue; } cl_platform_id *platforms = (cl_platform_id *) malloc( sizeof(cl_platform_id) * num_platforms); error = (*plt_fn_ptr)(num_platforms, platforms, NULL); if( error != CL_SUCCESS ){ free(platforms); debug(D_WARN, "Error in loading ICD platforms, skipping ICD"); continue; } cl_uint num_valid_platforms=0; cl_uint j; debug(D_LOG, "Try to load %d platforms", num_platforms); if (_allocate_platforms(num_platforms) < num_platforms) { free(platforms); debug(D_WARN, "Not enough platform allocated. Skipping ICD"); continue; } clIcdGetFunctionAddressForPlatformKHR_fn pltfn_fn_ptr = _get_function_addr(dlh, picd->ext_fn_ptr, "clIcdGetFunctionAddressForPlatformKHR"); clIcdSetPlatformDispatchDataKHR_fn spltdd_fn_ptr = _get_function_addr(dlh, picd->ext_fn_ptr, "clIcdSetPlatformDispatchDataKHR"); for(j=0; jextension_suffix=NULL; p->vicd=&_icds[i]; p->pid=platforms[j]; if (KHR_ICD2_HAS_TAG(p->pid) && !pltfn_fn_ptr) { debug(D_WARN, "Found icd 2 platform, but it is missing clIcdGetFunctionAddressForPlatformKHR, skipping it"); continue; } if (KHR_ICD2_HAS_TAG(p->pid) && !spltdd_fn_ptr) { debug(D_WARN, "Found icd 2 platform, but it is missing clIcdSetPlatformDispatchDataKHR, skipping it"); continue; } if (KHR_ICD2_HAS_TAG(p->pid) && !(((intptr_t)((p->pid)->dispatch->clUnloadCompiler)) == CL_ICD2_TAG_KHR)) { debug(D_WARN, "Found icd 2 platform, but it is missing clUnloadCompiler tag, skipping it"); continue; } if (KHR_ICD2_HAS_TAG(p->pid)) { _populate_dispatch_table(p->pid, pltfn_fn_ptr, &p->disp_data.dispatch); spltdd_fn_ptr(p->pid, &p->disp_data); debug(D_LOG, "Found icd 2 platform, using loader managed dispatch"); } /* If clGetPlatformInfo is not exported and we are here, it * means that OCL_ICD_ASSUME_ICD_EXTENSION. Si we try to take it * from the dispatch * table. If that fails too, we have to * bail. */ if (plt_info_ptr == NULL) { plt_info_ptr = KHR_ICD2_DISPATCH(p->pid)->clGetPlatformInfo; if (plt_info_ptr == NULL) { debug(D_WARN, "Missing clGetPlatformInfo even in ICD dispatch table, skipping it"); continue; } } #ifdef DEBUG_OCL_ICD if (debug_ocl_icd_mask & D_DUMP) { int log=debug_ocl_icd_mask & D_TRACE; debug_ocl_icd_mask &= ~D_TRACE; dump_platform(p->vicd->ext_fn_ptr, p->pid); debug_ocl_icd_mask |= log; } #endif { switch (_assume_ICD_extension()) { case ASSUME_ICD_EXTENSION_NO: /* checking the extension as required by the specs */ param_value=_malloc_clGetPlatformInfo(plt_info_ptr, p->pid, CL_PLATFORM_EXTENSIONS, "extensions"); if (param_value == NULL){ debug(D_WARN, "Skipping platform %i", j); continue; } debug(D_DUMP, "Supported extensions: %s", param_value); if( strstr(param_value, "cl_khr_icd") == NULL){ free(param_value); debug(D_WARN, "Missing khr extension in platform %i, skipping it", j); continue; } free(param_value); break; case ASSUME_ICD_EXTENSION_YES: /* Allow to workaround a bug in the Intel ICD used * with optirun : * - https://software.intel.com/en-us/forums/opencl/topic/328091 * - https://sourceforge.net/p/virtualgl/bugs/54/ */ debug(D_LOG, "Assuming cl_khr_icd extension without checking for it"); /* Fall through */ case ASSUME_ICD_EXTENSION_YES_AND_QUIET: /* Assuming an ICD extension, so we will try to * find the ICD specific version of * clGetPlatformInfo before knowing for sure that * the cl_khr_icd is really present */ break; default: debug(D_ALWAYS, "Internal error in _assume_ICD_extension, please report"); break; } } param_value=_malloc_clGetPlatformInfo(plt_info_ptr, p->pid, CL_PLATFORM_ICD_SUFFIX_KHR, "suffix"); if (param_value == NULL){ debug(D_WARN, "Skipping platform %i", j); continue; } p->extension_suffix = param_value; debug(D_DUMP|D_LOG, "Extension suffix: %s", param_value); #ifdef DEBUG_OCL_ICD param_value=_malloc_clGetPlatformInfo(plt_info_ptr, p->pid, CL_PLATFORM_PROFILE, "profile"); if (param_value != NULL){ debug(D_DUMP, "Profile: %s", param_value); free(param_value); } param_value=_malloc_clGetPlatformInfo(plt_info_ptr, p->pid, CL_PLATFORM_VERSION, "version"); p->version = param_value; if (param_value != NULL){ debug(D_DUMP, "Version: %s", param_value); free(param_value); } param_value=_malloc_clGetPlatformInfo(plt_info_ptr, p->pid, CL_PLATFORM_NAME, "name"); if (param_value != NULL){ debug(D_DUMP, "Name: %s", param_value); free(param_value); } param_value=_malloc_clGetPlatformInfo(plt_info_ptr, p->pid, CL_PLATFORM_VENDOR, "vendor"); if (param_value != NULL){ debug(D_DUMP, "Vendor: %s", param_value); free(param_value); } #endif num_valid_platforms++; _num_picds++; } if( num_valid_platforms != 0 ) { if ( _num_icds != i ) { picd->dl_handle = dlh; } dump_vendor_icd("after looking for platforms", &_icds[_num_icds]); _num_icds++; picd->num_platforms = num_valid_platforms; } else { dlclose(dlh); } free(platforms); } _sort_platforms(&_picds[0], _num_picds); } static void __initLayer(char * layer_path) { if(strlen(layer_path) == 0) return; void *handle=NULL; debug(D_LOG, "Considering file '%s'", layer_path); handle = dlopen(layer_path, RTLD_LAZY|RTLD_LOCAL); if (handle) { struct layer_icd * cur_layer = _first_layer; while (cur_layer) { if (cur_layer->dl_handle == handle) { debug(D_WARN, "Layer: %s already loaded", layer_path); dlclose(handle); return; } cur_layer = cur_layer->next_layer; } debug(D_LOG, "Layer: %s loaded", layer_path); clGetLayerInfo_fn clGetLayerInfo_ptr = (clGetLayerInfo_fn)dlsym(handle, "clGetLayerInfo"); clInitLayer_fn clInitLayer_ptr = (clInitLayer_fn)dlsym(handle, "clInitLayer"); if (!clGetLayerInfo_ptr || !clInitLayer_ptr) { dlclose(handle); debug(D_WARN, "Layer: %s was rejected", layer_path); return; } cl_layer_api_version layer_version = 0; cl_int err = clGetLayerInfo_ptr(CL_LAYER_API_VERSION, sizeof(layer_version), &layer_version, NULL); if (CL_SUCCESS != err) { debug(D_WARN, "Layer: %s api version could not be queried", layer_path); return; } if (CL_LAYER_API_VERSION_100 != layer_version) { debug(D_WARN, "Layer: %s api version not supported", layer_path); return; } const struct _cl_icd_dispatch *layer_dispatch = NULL; cl_uint layer_dispatch_num_entries = 0; const struct _cl_icd_dispatch *target_dispatch = NULL; struct layer_icd * new_layer = (struct layer_icd *)malloc(sizeof(struct layer_icd)); if (!new_layer) { debug(D_WARN, "Layer: %s could not be allocated", layer_path); return; } if (_first_layer) { target_dispatch = &(_first_layer->dispatch); } else { target_dispatch = &(master_dispatch); } err = clInitLayer_ptr(OCL_ICD_LAST_FUNCTION+1, target_dispatch, &layer_dispatch_num_entries, &layer_dispatch); if (err != CL_SUCCESS || !layer_dispatch || !layer_dispatch_num_entries) { dlclose(handle); free(new_layer); debug(D_WARN, "Layer: %s could not be initialized", layer_path); return; } new_layer->next_layer = _first_layer; _first_layer = new_layer; new_layer->dl_handle = handle; cl_uint limit = layer_dispatch_num_entries < OCL_ICD_LAST_FUNCTION+1 ? layer_dispatch_num_entries : OCL_ICD_LAST_FUNCTION+1; cl_uint i; for( i = 0; i < limit; i++) { ((void **)&(new_layer->dispatch))[i] = ((void **)layer_dispatch)[i] ? ((void **)layer_dispatch)[i] : ((void **)target_dispatch)[i]; } for( i = limit; i <= OCL_ICD_LAST_FUNCTION; i++) { ((void **)&(new_layer->dispatch))[i] = ((void **)target_dispatch)[i]; } #ifdef CLLAYERINFO new_layer->library_name = strdup(layer_path); new_layer->layer_info_fn_ptr = clGetLayerInfo_ptr; #endif } else { debug(D_WARN, "Layer: %s could not be loaded", layer_path); } } static void __initSystemLayers( void ) { struct stat buf; cl_uint num_lays = 0; int ret; struct dirent *ent; DIR *dir = NULL; const char* opencl_layer_path=getenv("OPENCL_LAYER_PATH"); if (! opencl_layer_path || opencl_layer_path[0]==0) { opencl_layer_path=ETC_OPENCL_LAYERS; debug(D_DUMP, "OPENCL_LAYER_PATH unset or empty. Using hard-coded path '%s'", opencl_layer_path); } else { debug(D_DUMP, "OPENCL_LAYER_PATH set to '%s', using it", opencl_layer_path); } debug(D_LOG,"Reading lay list from '%s'", opencl_layer_path); ret=stat(opencl_layer_path, &buf); if (ret != 0) { debug(D_WARN, "Cannot stat '%s'. Aborting", opencl_layer_path); return; } if (!S_ISDIR(buf.st_mode)) { debug(D_WARN, "'%s' is not a directory. Aborting", opencl_layer_path); return; } debug(D_LOG,"Reading lay list from '%s'", opencl_layer_path); dir = opendir(opencl_layer_path); if(dir == NULL) { if (errno == ENOTDIR) { debug(D_DUMP, "%s is not a directory. Aborting", opencl_layer_path); } return; } num_lays = _find_num_lays(dir); if(num_lays == 0) { return; } char **dir_elems = NULL; cl_uint real_num_lays = 0; dir_elems = (char **)malloc(num_lays*sizeof(char *)); if(!dir_elems) { return; } while( (ent=readdir(dir)) != NULL && real_num_lays < num_lays){ char * lib_path; unsigned int lib_path_length; if (!_string_end_with_lay(ent->d_name)) { continue; } lib_path_length = strlen(opencl_layer_path) + strlen(ent->d_name) + 2; lib_path = malloc(lib_path_length*sizeof(char)); if (!lib_path) { free(lib_path); continue; } sprintf(lib_path,"%s/%s", opencl_layer_path, ent->d_name); debug(D_LOG, "Considering file '%s'", lib_path); dir_elems[real_num_lays] = lib_path; real_num_lays++; } qsort(dir_elems, real_num_lays, sizeof(char *), compare_path); for(cl_uint j = 0; j < real_num_lays; j++) { unsigned int lib_path_length; char * err; char * lib_path = dir_elems[j]; FILE *f = fopen(lib_path,"r"); free(lib_path); if (f==NULL) { continue; } fseek(f, 0, SEEK_END); lib_path_length = ftell(f)+1; fseek(f, 0, SEEK_SET); if(lib_path_length == 1) { debug(D_WARN, "File contents too short, skipping LAY"); fclose(f); continue; } lib_path = malloc(lib_path_length*sizeof(char)); if (!lib_path) { continue; } err = fgets(lib_path, lib_path_length*sizeof(char), f); if( err == NULL ) { free(lib_path); debug(D_WARN, "Error while loading file contents, skipping LAY"); continue; } lib_path_length = strnlen(lib_path, lib_path_length); if( lib_path[lib_path_length-1] == '\n' ) lib_path[lib_path_length-1] = '\0'; __initLayer(lib_path); free(lib_path); } free(dir_elems); } static void __initLayers( void ) { __initSystemLayers(); char* layers_path=getenv("OPENCL_LAYERS"); if (layers_path) { char* layer_path = layers_path; char* next_layer_path = strchr(layers_path, ':'); while (layer_path) { if (next_layer_path) *next_layer_path++ = '\0'; __initLayer(layer_path); layer_path = next_layer_path; if (next_layer_path) next_layer_path = strchr(next_layer_path, ':'); } } } static void __initClIcd( void ) { debug_init(); cl_uint num_icds = 0; int is_dir = 0; DIR *dir = NULL; const char* dir_path=getenv("OCL_ICD_VENDORS"); const char* vendor_path=getenv("OPENCL_VENDOR_PATH"); if (! vendor_path || vendor_path[0]==0) { vendor_path=ETC_OPENCL_VENDORS; debug(D_DUMP, "OPENCL_VENDOR_PATH unset or empty. Using hard-coded path '%s'", vendor_path); } else { debug(D_DUMP, "OPENCL_VENDOR_PATH set to '%s', using it", vendor_path); } if (! dir_path || dir_path[0]==0) { dir_path=vendor_path; debug(D_DUMP, "OCL_ICD_VENDORS empty or not defined, using vendors path '%s'", dir_path); is_dir=1; } if (!is_dir) { struct stat buf; int ret=stat(dir_path, &buf); if (ret != 0 && errno != ENOENT) { debug(D_WARN, "Cannot stat '%s'. Aborting", dir_path); } if (ret == 0 && S_ISDIR(buf.st_mode)) { is_dir=1; } } if (!is_dir) { debug(D_LOG,"Only loading '%s' as an ICD", dir_path); num_icds = 1; dir=NULL; } else { debug(D_LOG,"Reading icd list from '%s'", dir_path); dir = opendir(dir_path); if(dir == NULL) { if (errno == ENOTDIR) { debug(D_DUMP, "%s is not a directory, trying to use it as a ICD libname", dir_path); } goto abort; } num_icds = _find_num_icds(dir); if(num_icds == 0) { goto abort; } } _icds = (struct vendor_icd*)malloc(num_icds * sizeof(struct vendor_icd)); if (_icds == NULL) { goto abort; } if (!is_dir) { if (_string_end_with_icd(dir_path)) { num_icds = 0; if (! _string_with_slash(dir_path)) { num_icds = _open_driver(0, vendor_path, dir_path); } if (num_icds == 0) { num_icds = _open_driver(0, NULL, dir_path); } } else { num_icds = _load_icd(0, dir_path); } } else { num_icds = _open_drivers(dir, dir_path); } if(num_icds == 0) { goto abort; } _find_and_check_platforms(num_icds); if(_num_icds == 0){ goto abort; } if (_num_icds < num_icds) { _icds = (struct vendor_icd*)realloc(_icds, _num_icds * sizeof(struct vendor_icd)); } debug(D_WARN, "%d valid vendor(s)!", _num_icds); if (dir != NULL){ closedir(dir); } __initLayers(); return; abort: _num_icds = 0; if (_icds) { free(_icds); _icds = NULL; } if (dir != NULL){ closedir(dir); } return; } #ifdef USE_PTHREAD static pthread_once_t once_init = PTHREAD_ONCE_INIT; #else static int gard=0; #endif volatile static __thread int in_init = 0; volatile static cl_uint _initialized = 0; static void _initClIcd_real( void ) { #ifdef USE_PTHREAD if (in_init) { /* probably reentrency, in_init is a __thread variable */ debug(D_WARN, "Executing init while already in init!"); } else { in_init=1; __sync_synchronize(); pthread_once(&once_init, &__initClIcd); __sync_synchronize(); in_init=0; } #else if (__sync_bool_compare_and_swap(&gard, 0, 1)) { in_init=1; __sync_synchronize(); __initClIcd(); __sync_synchronize(); in_init=0; } else { if (in_init) { /* probably reentrency (could also be preemptive user-level threads). */ } else { /* someone else started __initClIcd(). We wait until it ends. */ debug(D_WARN, "Waiting end of init"); while (!_initialized) { __sync_synchronize(); } debug(D_WARN, "Wait done"); } } #endif _initialized = 1; } void __attribute__((visibility("internal"))) _initClIcd_no_inline( void ) { if( __builtin_expect (_initialized, 1) ) return; _initClIcd_real(); } static inline void _initClIcd( void ) { if( __builtin_expect (_initialized, 1) ) return; _initClIcd_real(); } cl_platform_id __attribute__((visibility("internal"))) getDefaultPlatformID() { static cl_platform_id defaultPlatformID=NULL; static int defaultSet=0; if (! defaultSet) { do { if(_num_picds == 0) { break; } const char *default_platform = getenv("OCL_ICD_DEFAULT_PLATFORM"); int num_default_platform; char *end_scan; if (! default_platform) { num_default_platform = 0; } else { num_default_platform = strtol(default_platform, &end_scan, 10); if (*default_platform == '\0' || *end_scan != '\0') { break; } } if (num_default_platform < 0 || num_default_platform >= _num_picds) { break; } defaultPlatformID=_picds[num_default_platform].pid; } while(0); defaultSet=1; } return defaultPlatformID; } #pragma GCC visibility pop #if defined(__APPLE__) || defined(__MACOSX) #define hidden_alias(name) #else #define hidden_alias(name) \ typeof(name) name##_hid __attribute__ ((alias (#name), visibility("hidden"))) #endif typedef cl_uint cl_icdl_info; #define CL_ICDL_OCL_VERSION 1 #define CL_ICDL_VERSION 2 #define CL_ICDL_NAME 3 #define CL_ICDL_VENDOR 4 static cl_int clGetICDLoaderInfoOCLICD( cl_icdl_info param_name, size_t param_value_size, void * param_value, size_t * param_value_size_ret) { static const char cl_icdl_ocl_version[] = "OpenCL " OCL_ICD_OPENCL_VERSION; static const char cl_icdl_version[] = PACKAGE_VERSION; static const char cl_icdl_name[] = PACKAGE_NAME; static const char cl_icdl_vendor[] = "OCL Icd free software"; size_t size_string; const char * string_p; #define oclcase(name, NAME) \ case CL_ICDL_##NAME: \ string_p = cl_icdl_##name; \ size_string = sizeof(cl_icdl_##name); \ break switch ( param_name ) { oclcase(ocl_version,OCL_VERSION); oclcase(version,VERSION); oclcase(name,NAME); oclcase(vendor,VENDOR); default: return CL_INVALID_VALUE; break; } #undef oclcase if( param_value != NULL ) { if( size_string > param_value_size ) return CL_INVALID_VALUE; memcpy(param_value, string_p, size_string); } if( param_value_size_ret != NULL ) *param_value_size_ret = size_string; return CL_SUCCESS; } #define clGetExtensionFunctionAddress_body \ if( func_name == NULL ) \ return NULL; \ cl_uint suffix_length; \ cl_uint i; \ void * return_value=NULL; \ struct func_desc const * fn=&function_description[0]; \ int lenfn=strlen(func_name); \ if (lenfn > 3 && \ (strcmp(func_name+lenfn-3, "KHR")==0 || strcmp(func_name+lenfn-3, "EXT")==0)) { \ while (fn->name != NULL) { \ if (strcmp(func_name, fn->name)==0) \ RETURN(fn->addr); \ fn++; \ } \ } \ for(i=0; i<_num_picds; i++) { \ suffix_length = strlen(_picds[i].extension_suffix); \ if( suffix_length > strlen(func_name) ) \ continue; \ if(strcmp(_picds[i].extension_suffix, &func_name[strlen(func_name)-suffix_length]) == 0) \ RETURN((*_picds[i].vicd->ext_fn_ptr)(func_name)); \ } \ if(strcmp(func_name, "clGetICDLoaderInfoOCLICD") == 0) { \ return (void*)(void*(*)(void))(&clGetICDLoaderInfoOCLICD); \ } \ RETURN(return_value); __attribute__ ((visibility ("hidden"))) void * clGetExtensionFunctionAddress_disp(const char * func_name) { clGetExtensionFunctionAddress_body } CL_API_ENTRY void * CL_API_CALL clGetExtensionFunctionAddress(const char * func_name) CL_API_SUFFIX__VERSION_1_0 { debug_trace(); _initClIcd(); if (_first_layer) return _first_layer->dispatch.clGetExtensionFunctionAddress(func_name); clGetExtensionFunctionAddress_body } hidden_alias(clGetExtensionFunctionAddress); #define clGetPlatformIDs_body \ if( platforms == NULL && num_platforms == NULL ) \ RETURN(CL_INVALID_VALUE); \ if( num_entries == 0 && platforms != NULL ) \ RETURN(CL_INVALID_VALUE); \ if( _num_icds == 0 || _num_picds == 0 ) { \ if ( num_platforms != NULL ) \ *num_platforms = 0; \ RETURN(CL_PLATFORM_NOT_FOUND_KHR); \ } \ \ cl_uint i; \ if( num_platforms != NULL ){ \ *num_platforms = _num_picds; \ } \ if( platforms != NULL ) { \ cl_uint n_platforms = _num_picds < num_entries ? _num_picds : num_entries; \ for( i=0; idispatch.clGetPlatformIDs(num_entries, platforms, num_platforms); clGetPlatformIDs_body } hidden_alias(clGetPlatformIDs); #define RETURN_WITH_ERRCODE(errvar, errvalue, retvalue) \ do { \ if(errvar) { \ *errvar=errvalue; \ } \ RETURN(NULL); \ } while(0) #define CHECK_PLATFORM(__pid) \ ({ \ cl_platform_id _pid=(__pid); \ int good=0; \ cl_uint j; \ for( j=0; j<_num_picds; j++) { \ if( _picds[j].pid == _pid) { \ good=1; \ break; \ } \ } \ good; \ }) #define clCreateContext_body \ cl_uint i=0; \ if( properties != NULL){ \ while( properties[i] != 0 ) { \ if( properties[i] == CL_CONTEXT_PLATFORM ) { \ if((struct _cl_platform_id *) properties[i+1] == NULL) { \ if(errcode_ret) { \ *errcode_ret = CL_INVALID_PLATFORM; \ } \ RETURN(NULL); \ } else { \ if( !CHECK_PLATFORM((cl_platform_id) properties[i+1]) ) { \ RETURN_WITH_ERRCODE(errcode_ret, CL_INVALID_PLATFORM, NULL); \ } \ } \ RETURN(KHR_ICD2_DISPATCH((struct _cl_platform_id *) properties[i+1]) \ ->clCreateContext(properties, num_devices, devices, \ pfn_notify, user_data, errcode_ret)); \ } \ i += 2; \ } \ } \ if(devices == NULL || num_devices == 0) { \ RETURN_WITH_ERRCODE(errcode_ret, CL_INVALID_VALUE, NULL); \ } \ if((struct _cl_device_id *)devices[0] == NULL) { \ RETURN_WITH_ERRCODE(errcode_ret, CL_INVALID_DEVICE, NULL); \ } \ RETURN(KHR_ICD2_DISPATCH((struct _cl_device_id *)devices[0]) \ ->clCreateContext(properties, num_devices, devices, \ pfn_notify, user_data, errcode_ret)); __attribute__ ((visibility ("hidden"))) cl_context clCreateContext_disp(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 ){ clCreateContext_body } CL_API_ENTRY cl_context CL_API_CALL clCreateContext(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 { debug_trace(); _initClIcd(); if (_first_layer) return _first_layer->dispatch.clCreateContext(properties, num_devices, devices, pfn_notify, user_data, errcode_ret); clCreateContext_body } hidden_alias(clCreateContext); #define clCreateContextFromType_body \ if(_num_picds == 0) { \ goto out; \ } \ cl_uint i=0; \ if( properties != NULL){ \ while( properties[i] != 0 ) { \ if( properties[i] == CL_CONTEXT_PLATFORM ) { \ if( (struct _cl_platform_id *) properties[i+1] == NULL ) { \ goto out; \ } else { \ if( !CHECK_PLATFORM((cl_platform_id) properties[i+1]) ) { \ goto out; \ } \ } \ return KHR_ICD2_DISPATCH((struct _cl_platform_id *) properties[i+1]) \ ->clCreateContextFromType(properties, device_type, \ pfn_notify, user_data, errcode_ret); \ } \ i += 2; \ } \ } else { \ cl_platform_id default_platform=getDefaultPlatformID(); \ RETURN(KHR_ICD2_DISPATCH(default_platform)->clCreateContextFromType \ (properties, device_type, pfn_notify, user_data, errcode_ret)); \ } \ out: \ RETURN_WITH_ERRCODE(errcode_ret, CL_INVALID_PLATFORM, NULL); __attribute__ ((visibility ("hidden"))) cl_context clCreateContextFromType_disp(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) { clCreateContextFromType_body } CL_API_ENTRY cl_context CL_API_CALL clCreateContextFromType(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 { debug_trace(); _initClIcd(); if (_first_layer) return _first_layer->dispatch.clCreateContextFromType(properties, device_type, pfn_notify, user_data, errcode_ret); clCreateContextFromType_body } hidden_alias(clCreateContextFromType); #define clGetGLContextInfoKHR_body \ cl_uint i=0; \ if( properties != NULL){ \ while( properties[i] != 0 ) { \ if( properties[i] == CL_CONTEXT_PLATFORM ) { \ if( (struct _cl_platform_id *) properties[i+1] == NULL ) { \ RETURN(CL_INVALID_PLATFORM); \ } else { \ if( !CHECK_PLATFORM((cl_platform_id) properties[i+1]) ) { \ RETURN(CL_INVALID_PLATFORM); \ } \ } \ RETURN(KHR_ICD2_DISPATCH((struct _cl_platform_id *) properties[i+1]) \ ->clGetGLContextInfoKHR(properties, param_name, \ param_value_size, param_value, param_value_size_ret)); \ } \ i += 2; \ } \ } \ RETURN(CL_INVALID_PLATFORM); __attribute__ ((visibility ("hidden"))) cl_int clGetGLContextInfoKHR_disp(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) { clGetGLContextInfoKHR_body } 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 { debug_trace(); _initClIcd(); if (_first_layer) return _first_layer->dispatch.clGetGLContextInfoKHR(properties, param_name, param_value_size, param_value, param_value_size_ret); clGetGLContextInfoKHR_body } hidden_alias(clGetGLContextInfoKHR); #define clWaitForEvents_body \ if( num_events == 0 || event_list == NULL ) \ RETURN(CL_INVALID_VALUE); \ if( (struct _cl_event *)event_list[0] == NULL ) \ RETURN(CL_INVALID_EVENT); \ RETURN(KHR_ICD2_DISPATCH((struct _cl_event *)event_list[0]) \ ->clWaitForEvents(num_events, event_list)); __attribute__ ((visibility ("hidden"))) cl_int clWaitForEvents_disp(cl_uint num_events, const cl_event * event_list) CL_API_SUFFIX__VERSION_1_0 { clWaitForEvents_body } CL_API_ENTRY cl_int CL_API_CALL clWaitForEvents(cl_uint num_events, const cl_event * event_list) CL_API_SUFFIX__VERSION_1_0 { debug_trace(); if (_first_layer) return _first_layer->dispatch.clWaitForEvents(num_events, event_list); clWaitForEvents_body } hidden_alias(clWaitForEvents); #define clUnloadCompiler_body \ RETURN(CL_SUCCESS); __attribute__ ((visibility ("hidden"))) cl_int clUnloadCompiler_disp(void) { clUnloadCompiler_body } CL_API_ENTRY cl_int CL_API_CALL clUnloadCompiler(void) CL_API_SUFFIX__VERSION_1_0 { debug_trace(); if (_first_layer) return _first_layer->dispatch.clUnloadCompiler(); clUnloadCompiler_body } hidden_alias(clUnloadCompiler); ocl-icd-2.3.3/ocl_icd_loader.h000066400000000000000000000106741477331540600161460ustar00rootroot00000000000000/** Copyright (c) 2020, Brice Videau Copyright (c) 2013, Vincent Danjean All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #ifndef __OCL_ICD_LOADER_H #define __OCL_ICD_LOADER_H #include "ocl_icd.h" #include "ocl_icd_loader_gen.h" #include cl_platform_id __attribute__((visibility("internal"))) getDefaultPlatformID(); void __attribute__((visibility("internal"))) _initClIcd_no_inline(void); static inline cl_platform_id selectPlatformID(cl_platform_id pid) { if (pid) return pid; return getDefaultPlatformID(); } typedef cl_uint cl_layer_info; typedef cl_uint cl_layer_api_version; #define CL_LAYER_API_VERSION 0x4240 #define CL_LAYER_NAME 0x4241 #define CL_LAYER_API_VERSION_100 100 typedef __typeof__(clGetPlatformInfo) *clGetPlatformInfo_fn; typedef cl_int (CL_API_CALL *clGetLayerInfo_fn)( cl_layer_info param_name, size_t param_value_size, void *param_value, size_t *param_value_size_ret); typedef cl_int (CL_API_CALL *clInitLayer_fn)( cl_uint num_entries, const struct _cl_icd_dispatch *target_dispatch, cl_uint *num_entries_out, const struct _cl_icd_dispatch **layer_dispatch); struct layer_icd; struct layer_icd { void *dl_handle; struct _cl_icd_dispatch dispatch; struct layer_icd *next_layer; #ifdef CLLAYERINFO char *library_name; void *layer_info_fn_ptr; #endif }; #ifndef CL_ICD2_TAG_KHR #if INTPTR_MAX == INT32_MAX #define CL_ICD2_TAG_KHR ((intptr_t)0x434C3331) #else #define CL_ICD2_TAG_KHR ((intptr_t)0x4F50454E434C3331) #endif typedef void * CL_API_CALL clIcdGetFunctionAddressForPlatformKHR_t( cl_platform_id platform, const char* func_name); typedef clIcdGetFunctionAddressForPlatformKHR_t * clIcdGetFunctionAddressForPlatformKHR_fn; typedef cl_int CL_API_CALL clIcdSetPlatformDispatchDataKHR_t( cl_platform_id platform, void *disp_data); typedef clIcdSetPlatformDispatchDataKHR_t * clIcdSetPlatformDispatchDataKHR_fn; #endif // CL_ICD2_TAG_KHR __attribute__((visibility("hidden"))) extern void _populate_dispatch_table( cl_platform_id platform, clIcdGetFunctionAddressForPlatformKHR_fn pltfn_fn_ptr, struct _cl_icd_dispatch* dispatch); struct _cl_disp_data { struct _cl_icd_dispatch dispatch; }; #define KHR_ICD2_HAS_TAG(object) \ (((intptr_t)((object)->dispatch->clGetPlatformIDs)) == CL_ICD2_TAG_KHR) #define KHR_ICD2_DISPATCH(object) \ (KHR_ICD2_HAS_TAG(object) ? \ &(object)->disp_data->dispatch : \ (object)->dispatch) struct platform_icd { char *extension_suffix; char *version; struct vendor_icd *vicd; cl_platform_id pid; cl_uint ngpus; /* number of GPU devices */ cl_uint ncpus; /* number of CPU devices */ cl_uint ndevs; /* total number of devices, of all types */ struct _cl_disp_data disp_data; }; __attribute__((visibility("hidden"))) extern struct layer_icd *_first_layer; #endif ocl-icd-2.3.3/ocl_interface.yaml000066400000000000000000001664411477331540600165400ustar00rootroot00000000000000# Copyright (c) 2012-2020, Brice Videau # Copyright (c) 2012-2020, Vincent Danjean # All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are met: # # 1. Redistributions of source code must retain the above copyright notice, this # list of conditions and the following disclaimer. # 2. Redistributions in binary form must reproduce the above copyright notice, # this list of conditions and the following disclaimer in the documentation # and/or other materials provided with the distribution. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND # ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE # DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR # ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES # (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND # ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # # Do not edit this file. It is automatically generated. # In Intel (OpenCL 1.1): # * clSetCommandQueueProperty(13): nil (deprecated in 1.1) # * clGetGLContextInfoKHR(74): function present with its symbol # * 75-80: nil # * 92: correspond to symbol clGetKernelArgInfo (first abandonned version?) # * 93-: garbage # In nvidia (OpenCL 1.1): # * clGetGLContextInfoKHR(74): function present but no symbol # * 75-80: nil # * 89-: nil # * only two OpenCL symbols: clGetPlatformInfo(1) and clGetExtensionFunctionAddress(65) # In AMD (OpenCL 1.2): # * clGetPlatformIDs(0): nil (symbol present) # * clGetGLContextInfoKHR(74): function present but no symbol # * 75-80: nil # * 92: nil # * 109-118: nil # * 119-: garbage --- 0: |- CL_API_ENTRY cl_int CL_API_CALL clGetPlatformIDs(cl_uint /* num_entries */, cl_platform_id * /* platforms */, cl_uint * /* num_platforms */) CL_API_SUFFIX__VERSION_1_0; 1: |- CL_API_ENTRY cl_int CL_API_CALL clGetPlatformInfo(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; 2: |- CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDs(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; 3: |- CL_API_ENTRY cl_int CL_API_CALL clGetDeviceInfo(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; 4: |- CL_API_ENTRY cl_context CL_API_CALL clCreateContext(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; 5: |- CL_API_ENTRY cl_context CL_API_CALL clCreateContextFromType(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; 6: |- CL_API_ENTRY cl_int CL_API_CALL clRetainContext(cl_context /* context */) CL_API_SUFFIX__VERSION_1_0; 7: |- CL_API_ENTRY cl_int CL_API_CALL clReleaseContext(cl_context /* context */) CL_API_SUFFIX__VERSION_1_0; 8: |- CL_API_ENTRY cl_int CL_API_CALL clGetContextInfo(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; 9: |- CL_API_ENTRY cl_command_queue CL_API_CALL clCreateCommandQueue(cl_context /* context */, cl_device_id /* device */, cl_command_queue_properties /* properties */, cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0; 10: |- CL_API_ENTRY cl_int CL_API_CALL clRetainCommandQueue(cl_command_queue /* command_queue */) CL_API_SUFFIX__VERSION_1_0; 11: |- CL_API_ENTRY cl_int CL_API_CALL clReleaseCommandQueue(cl_command_queue /* command_queue */) CL_API_SUFFIX__VERSION_1_0; 12: |- CL_API_ENTRY cl_int CL_API_CALL clGetCommandQueueInfo(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; 13: |- 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; 14: |- CL_API_ENTRY cl_mem CL_API_CALL clCreateBuffer(cl_context /* context */, cl_mem_flags /* flags */, size_t /* size */, void * /* host_ptr */, cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0; 15: |- CL_API_ENTRY cl_mem CL_API_CALL clCreateImage2D(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; 16: |- CL_API_ENTRY cl_mem CL_API_CALL clCreateImage3D(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; 17: |- CL_API_ENTRY cl_int CL_API_CALL clRetainMemObject(cl_mem /* memobj */) CL_API_SUFFIX__VERSION_1_0; 18: |- CL_API_ENTRY cl_int CL_API_CALL clReleaseMemObject(cl_mem /* memobj */) CL_API_SUFFIX__VERSION_1_0; 19: |- CL_API_ENTRY cl_int CL_API_CALL clGetSupportedImageFormats(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; 20: |- CL_API_ENTRY cl_int CL_API_CALL clGetMemObjectInfo(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; 21: |- CL_API_ENTRY cl_int CL_API_CALL clGetImageInfo(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; 22: |- CL_API_ENTRY cl_sampler CL_API_CALL clCreateSampler(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; 23: |- CL_API_ENTRY cl_int CL_API_CALL clRetainSampler(cl_sampler /* sampler */) CL_API_SUFFIX__VERSION_1_0; 24: |- CL_API_ENTRY cl_int CL_API_CALL clReleaseSampler(cl_sampler /* sampler */) CL_API_SUFFIX__VERSION_1_0; 25: |- CL_API_ENTRY cl_int CL_API_CALL clGetSamplerInfo(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; 26: |- CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithSource(cl_context /* context */, cl_uint /* count */, const char ** /* strings */, const size_t * /* lengths */, cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0; 27: |- CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithBinary(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; 28: |- CL_API_ENTRY cl_int CL_API_CALL clRetainProgram(cl_program /* program */) CL_API_SUFFIX__VERSION_1_0; 29: |- CL_API_ENTRY cl_int CL_API_CALL clReleaseProgram(cl_program /* program */) CL_API_SUFFIX__VERSION_1_0; 30: |- CL_API_ENTRY cl_int CL_API_CALL clBuildProgram(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; 31: |- CL_API_ENTRY cl_int CL_API_CALL clUnloadCompiler( void ) CL_API_SUFFIX__VERSION_1_0; 32: |- CL_API_ENTRY cl_int CL_API_CALL clGetProgramInfo(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; 33: |- CL_API_ENTRY cl_int CL_API_CALL clGetProgramBuildInfo(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; 34: |- CL_API_ENTRY cl_kernel CL_API_CALL clCreateKernel(cl_program /* program */, const char * /* kernel_name */, cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0; 35: |- CL_API_ENTRY cl_int CL_API_CALL clCreateKernelsInProgram(cl_program /* program */, cl_uint /* num_kernels */, cl_kernel * /* kernels */, cl_uint * /* num_kernels_ret */) CL_API_SUFFIX__VERSION_1_0; 36: |- CL_API_ENTRY cl_int CL_API_CALL clRetainKernel(cl_kernel /* kernel */) CL_API_SUFFIX__VERSION_1_0; 37: |- CL_API_ENTRY cl_int CL_API_CALL clReleaseKernel(cl_kernel /* kernel */) CL_API_SUFFIX__VERSION_1_0; 38: |- CL_API_ENTRY cl_int CL_API_CALL clSetKernelArg(cl_kernel /* kernel */, cl_uint /* arg_index */, size_t /* arg_size */, const void * /* arg_value */) CL_API_SUFFIX__VERSION_1_0; 39: |- CL_API_ENTRY cl_int CL_API_CALL clGetKernelInfo(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; 40: |- CL_API_ENTRY cl_int CL_API_CALL clGetKernelWorkGroupInfo(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; 41: |- CL_API_ENTRY cl_int CL_API_CALL clWaitForEvents(cl_uint /* num_events */, const cl_event * /* event_list */) CL_API_SUFFIX__VERSION_1_0; 42: |- CL_API_ENTRY cl_int CL_API_CALL clGetEventInfo(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; 43: |- CL_API_ENTRY cl_int CL_API_CALL clRetainEvent(cl_event /* event */) CL_API_SUFFIX__VERSION_1_0; 44: |- CL_API_ENTRY cl_int CL_API_CALL clReleaseEvent(cl_event /* event */) CL_API_SUFFIX__VERSION_1_0; 45: |- CL_API_ENTRY cl_int CL_API_CALL clGetEventProfilingInfo(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; 46: |- CL_API_ENTRY cl_int CL_API_CALL clFlush(cl_command_queue /* command_queue */) CL_API_SUFFIX__VERSION_1_0; 47: |- CL_API_ENTRY cl_int CL_API_CALL clFinish(cl_command_queue /* command_queue */) CL_API_SUFFIX__VERSION_1_0; 48: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadBuffer(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; 49: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteBuffer(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; 50: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBuffer(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; 51: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadImage(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; 52: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteImage(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; 53: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyImage(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; 54: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyImageToBuffer(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; 55: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBufferToImage(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; 56: |- CL_API_ENTRY void * CL_API_CALL clEnqueueMapBuffer(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; 57: |- CL_API_ENTRY void * CL_API_CALL clEnqueueMapImage(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; 58: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueUnmapMemObject(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; 59: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueNDRangeKernel(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; 60: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueTask(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; 61: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueNativeKernel(cl_command_queue /* command_queue */, void (*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; 62: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueMarker(cl_command_queue /* command_queue */, cl_event * /* event */) CL_API_SUFFIX__VERSION_1_0; 63: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueWaitForEvents(cl_command_queue /* command_queue */, cl_uint /* num_events */, const cl_event * /* event_list */) CL_API_SUFFIX__VERSION_1_0; 64: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueBarrier(cl_command_queue /* command_queue */) CL_API_SUFFIX__VERSION_1_0; 65: |- CL_API_ENTRY void * CL_API_CALL clGetExtensionFunctionAddress(const char * /* func_name */) CL_API_SUFFIX__VERSION_1_0; 66: |- 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; 67: |- CL_API_ENTRY 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_API_SUFFIX__VERSION_1_0; 68: |- CL_API_ENTRY 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_API_SUFFIX__VERSION_1_0; 69: |- 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; 70: |- 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; 71: |- 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; 72: |- 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; 73: |- 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; 74: |- 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; 75: |- CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromD3D10KHR(cl_platform_id /* platform */, cl_d3d10_device_source_khr /* d3d_device_source */, void * /* d3d_object */, cl_d3d10_device_set_khr /* d3d_device_set */, cl_uint /* num_entries */, cl_device_id * /* devices */, cl_uint * /* num_devices */) CL_API_SUFFIX__VERSION_1_0; 76: |- CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10BufferKHR(cl_context /* context */, cl_mem_flags /* flags */, ID3D10Buffer * /* resource */, cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0; 77: |- CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture2DKHR(cl_context /* context */, cl_mem_flags /* flags */, ID3D10Texture2D * /* resource */, UINT /* subresource */, cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0; 78: |- CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture3DKHR(cl_context /* context */, cl_mem_flags /* flags */, ID3D10Texture3D * /* resource */, UINT /* subresource */, cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0; 79: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D10ObjectsKHR(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; 80: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseD3D10ObjectsKHR(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; 81: |- CL_API_ENTRY cl_int CL_API_CALL clSetEventCallback(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; 82: |- CL_API_ENTRY cl_mem CL_API_CALL clCreateSubBuffer(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; 83: |- CL_API_ENTRY cl_int CL_API_CALL clSetMemObjectDestructorCallback(cl_mem /* memobj */, void (CL_CALLBACK * /*pfn_notify*/)( cl_mem /* memobj */, void* /*user_data*/), void * /*user_data */ ) CL_API_SUFFIX__VERSION_1_1; 84: |- CL_API_ENTRY cl_event CL_API_CALL clCreateUserEvent(cl_context /* context */, cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_1; 85: |- CL_API_ENTRY cl_int CL_API_CALL clSetUserEventStatus(cl_event /* event */, cl_int /* execution_status */) CL_API_SUFFIX__VERSION_1_1; 86: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadBufferRect(cl_command_queue /* command_queue */, cl_mem /* buffer */, cl_bool /* blocking_read */, const size_t * /* buffer_origin */, const size_t * /* host_origin */, 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; 87: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteBufferRect(cl_command_queue /* command_queue */, cl_mem /* buffer */, cl_bool /* blocking_write */, const size_t * /* buffer_origin */, const size_t * /* host_origin */, 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; 88: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBufferRect(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; 89: |- 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_API_SUFFIX__VERSION_1_1; 90: |- CL_API_ENTRY cl_int CL_API_CALL clRetainDeviceEXT( cl_device_id /*device*/ ) CL_API_SUFFIX__VERSION_1_1; 91: |- CL_API_ENTRY cl_int CL_API_CALL clReleaseDeviceEXT( cl_device_id /*device*/ ) CL_API_SUFFIX__VERSION_1_1; 92: |- CL_API_ENTRY cl_event CL_API_CALL clCreateEventFromGLsyncKHR(cl_context /* context */, cl_GLsync /* cl_GLsync */, cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_1; 93: |- CL_API_ENTRY cl_int CL_API_CALL clCreateSubDevices(cl_device_id /* in_device */, const cl_device_partition_property * /* properties */, cl_uint /* num_devices */, cl_device_id * /* out_devices */, cl_uint * /* num_devices_ret */) CL_API_SUFFIX__VERSION_1_2; 94: |- CL_API_ENTRY cl_int CL_API_CALL clRetainDevice(cl_device_id /* device */) CL_API_SUFFIX__VERSION_1_2; 95: |- CL_API_ENTRY cl_int CL_API_CALL clReleaseDevice(cl_device_id /* device */) CL_API_SUFFIX__VERSION_1_2; 96: |- CL_API_ENTRY cl_mem CL_API_CALL clCreateImage(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; 97: |- CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithBuiltInKernels(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; 98: |- CL_API_ENTRY cl_int CL_API_CALL clCompileProgram(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; 99: |- CL_API_ENTRY cl_program CL_API_CALL clLinkProgram(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; 100: |- CL_API_ENTRY cl_int CL_API_CALL clUnloadPlatformCompiler(cl_platform_id /* platform */) CL_API_SUFFIX__VERSION_1_2; 101: |- CL_API_ENTRY cl_int CL_API_CALL clGetKernelArgInfo(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; 102: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueFillBuffer(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; 103: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueFillImage(cl_command_queue /* command_queue */, cl_mem /* image */, const void * /* fill_color */, const size_t * /* 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_2; 104: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueMigrateMemObjects(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; 105: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueMarkerWithWaitList(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; 106: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueBarrierWithWaitList(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; 107: |- CL_API_ENTRY void * CL_API_CALL clGetExtensionFunctionAddressForPlatform(cl_platform_id /* platform */, const char * /* func_name */) CL_API_SUFFIX__VERSION_1_2; 108: |- 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; 109: |- CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromD3D11KHR(cl_platform_id /* platform */, cl_d3d11_device_source_khr /* d3d_device_source */, void * /* d3d_object */, cl_d3d11_device_set_khr /* d3d_device_set */, cl_uint /* num_entries */, cl_device_id * /* devices */, cl_uint * /* num_devices */) CL_API_SUFFIX__VERSION_1_2; 110: |- CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11BufferKHR(cl_context /* context */, cl_mem_flags /* flags */, ID3D11Buffer * /* resource */, cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_2; 111: |- CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture2DKHR(cl_context /* context */, cl_mem_flags /* flags */, ID3D11Texture2D * /* resource */, UINT /* subresource */, cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_2; 112: |- CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture3DKHR(cl_context /* context */, cl_mem_flags /* flags */, ID3D11Texture3D * /* resource */, UINT /* subresource */, cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_2; 113: |- CL_API_ENTRY cl_mem CL_API_CALL clCreateFromDX9MediaSurfaceKHR(cl_context /* context */, cl_mem_flags /* flags */, cl_dx9_media_adapter_type_khr /* adapter_type */, void * /* surface_info */, cl_uint /* plane */, cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_2; 114: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D11ObjectsKHR(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_2; 115: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseD3D11ObjectsKHR(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_2; 116: |- CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromDX9MediaAdapterKHR(cl_platform_id /* platform */, cl_uint /* num_media_adapters */, cl_dx9_media_adapter_type_khr * /* media_adapter_type */, void * /* media_adapters */, cl_dx9_media_adapter_set_khr /* media_adapter_set */, cl_uint /* num_entries */, cl_device_id * /* devices */, cl_uint * /* num_devices */) CL_API_SUFFIX__VERSION_1_2; 117: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireDX9MediaSurfacesKHR(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_2; 118: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseDX9MediaSurfacesKHR(cl_command_queue /* command_queue */, cl_uint /* num_objects */, 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_2; 119: |- 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; 120: |- 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; 121: |- 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; 122: |- 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; 123: |- CL_API_ENTRY cl_command_queue CL_API_CALL clCreateCommandQueueWithProperties(cl_context /* context */, cl_device_id /* device */, const cl_queue_properties * /* properties */, cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_2_0; 124: |- CL_API_ENTRY cl_mem CL_API_CALL clCreatePipe(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; 125: |- CL_API_ENTRY cl_int CL_API_CALL clGetPipeInfo(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; 126: |- CL_API_ENTRY void * CL_API_CALL clSVMAlloc(cl_context /* context */, cl_svm_mem_flags /* flags */, size_t /* size */, cl_uint /* alignment */) CL_API_SUFFIX__VERSION_2_0; 127: |- CL_API_ENTRY void CL_API_CALL clSVMFree(cl_context /* context */, void * /* svm_pointer */) CL_API_SUFFIX__VERSION_2_0; 128: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMFree(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; 129: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMemcpy(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; 130: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMemFill(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; 131: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMap(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; 132: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMUnmap(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; 133: |- CL_API_ENTRY cl_sampler CL_API_CALL clCreateSamplerWithProperties(cl_context /* context */, const cl_sampler_properties * /* normalized_coords */, cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_2_0; 134: |- CL_API_ENTRY cl_int CL_API_CALL clSetKernelArgSVMPointer(cl_kernel /* kernel */, cl_uint /* arg_index */, const void * /* arg_value */) CL_API_SUFFIX__VERSION_2_0; 135: |- CL_API_ENTRY cl_int CL_API_CALL clSetKernelExecInfo(cl_kernel /* kernel */, cl_kernel_exec_info /* param_name */, size_t /* param_value_size */, const void * /* param_value */) CL_API_SUFFIX__VERSION_2_0; 136: |- 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_API_SUFFIX__VERSION_2_0; 137: |- CL_API_ENTRY cl_kernel CL_API_CALL clCloneKernel(cl_kernel /* source_kernel */, cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_2_1; 138: |- CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithIL(cl_context /* context */, const void* /* il */, size_t /* length */, cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_2_1; 139: |- CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMigrateMem(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; 140: |- CL_API_ENTRY cl_int CL_API_CALL clGetDeviceAndHostTimer(cl_device_id /* device */, cl_ulong* /* device_timestamp */, cl_ulong* /* host_timestamp */) CL_API_SUFFIX__VERSION_2_1; 141: |- CL_API_ENTRY cl_int CL_API_CALL clGetHostTimer(cl_device_id /* device */, cl_ulong * /* host_timestamp */) CL_API_SUFFIX__VERSION_2_1; 142: |- CL_API_ENTRY cl_int CL_API_CALL clGetKernelSubGroupInfo(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_1; 143: |- CL_API_ENTRY cl_int CL_API_CALL clSetDefaultDeviceCommandQueue(cl_context /* context */, cl_device_id /* device */, cl_command_queue /* command_queue */) CL_API_SUFFIX__VERSION_2_1; 144: |- CL_API_ENTRY cl_int CL_API_CALL clSetProgramReleaseCallback(cl_program /* program */, void (CL_CALLBACK * /* pfn_notify */)(cl_program /* program */, void * /* user_data */), void * /* user_data */) CL_API_SUFFIX__VERSION_2_2; 145: |- CL_API_ENTRY cl_int CL_API_CALL clSetProgramSpecializationConstant(cl_program /* program */, cl_uint /* spec_id */, size_t /* spec_size */, const void* /* spec_value */) CL_API_SUFFIX__VERSION_2_2; 146: |- CL_API_ENTRY cl_mem CL_API_CALL clCreateBufferWithProperties(cl_context /* context */, const cl_mem_properties * /* properties */, cl_mem_flags /* flags */, size_t /* size */, void * /* host_ptr */, cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_3_0; 147: |- CL_API_ENTRY cl_mem CL_API_CALL clCreateImageWithProperties(cl_context /* context */, const cl_mem_properties * /* properties */, 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_3_0; 148: |- CL_API_ENTRY cl_int CL_API_CALL clSetContextDestructorCallback(cl_context /* context */, void (CL_CALLBACK * /* pfn_notify */)(cl_context /* context */, void* /* user_data */), void * /* user_data */) CL_API_SUFFIX__VERSION_3_0; ocl-icd-2.3.3/ocl_test.c000066400000000000000000000071731477331540600150330ustar00rootroot00000000000000/** Copyright (c) 2012-2020, Brice Videau All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #define CL_TARGET_OPENCL_VERSION 300 #include #include #include #include void print_error(cl_int error) { switch (error) { case CL_SUCCESS: break ; case CL_PLATFORM_NOT_FOUND_KHR: printf("No platforms found!\n"); break; case CL_INVALID_PLATFORM: printf("Invalid platform\n"); break; default: printf("OpenCL error: %i\n", error); } } void show_platform(cl_platform_id pid, int show_extensions) { char *platform_vendor; size_t param_value_size_ret; cl_int error; error = clGetPlatformInfo(pid, CL_PLATFORM_VENDOR, 0, NULL, ¶m_value_size_ret ); print_error(error); if (error != CL_SUCCESS) return; platform_vendor = (char *)malloc(param_value_size_ret); clGetPlatformInfo(pid, CL_PLATFORM_VENDOR, param_value_size_ret, platform_vendor, NULL ); printf("%s\n",platform_vendor); free(platform_vendor); if (show_extensions) { error = clGetPlatformInfo(pid, CL_PLATFORM_EXTENSIONS, 0, NULL, ¶m_value_size_ret ); print_error(error); platform_vendor = (char *)malloc(param_value_size_ret); clGetPlatformInfo(pid, CL_PLATFORM_EXTENSIONS, param_value_size_ret, platform_vendor, NULL ); printf("Extensions: %s\n",platform_vendor); free(platform_vendor); } } int main(int argc, char* argv[]) { cl_platform_id *platforms; cl_uint num_platforms; cl_int error; int show_extensions=0; if (argc >= 2 && strcmp(argv[1], "--show-extensions")==0) { show_extensions=1; argv++; } int default_platform=0; if (argc >= 2 && strcmp(argv[1], "--default-platform")==0) { default_platform=1; } error = clGetPlatformIDs(0, NULL, &num_platforms); if( error == CL_SUCCESS ) { printf("Found %u platforms!\n", num_platforms); } else if( error == CL_PLATFORM_NOT_FOUND_KHR ) { print_error(error); if (default_platform) { show_platform(NULL, show_extensions); } exit(0); } else { print_error(error); exit(-1); } platforms = (cl_platform_id *)malloc(sizeof(cl_platform_id *) * num_platforms); error = clGetPlatformIDs(num_platforms, platforms, NULL); print_error(error); cl_uint i; for(i=0; i All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wcpp" # define CL_USE_DEPRECATED_OPENCL_1_0_APIS # define CL_USE_DEPRECATED_OPENCL_1_1_APIS # define CL_USE_DEPRECATED_OPENCL_1_2_APIS # define CL_USE_DEPRECATED_OPENCL_2_0_APIS # define CL_USE_DEPRECATED_OPENCL_2_1_APIS # define CL_USE_DEPRECATED_OPENCL_2_2_APIS # define CL_TARGET_OPENCL_VERSION 300 # if defined(__APPLE__) || defined(__MACOSX) # include # else # include # endif #pragma GCC diagnostic pop #include #include #include typedef enum { CL_ICDL_OCL_VERSION=1, CL_ICDL_VERSION=2, CL_ICDL_NAME=3, CL_ICDL_VENDOR=4, } cl_icdl_info; typedef cl_int (*clGetICDLoaderInfoOCLICD_fn)( cl_icdl_info param_name, size_t param_value_size, void * param_value, size_t * param_value_size_ret); int main(int argc, char* argv[]) { cl_int error; clGetICDLoaderInfoOCLICD_fn clGetICDLoaderInfoOCLICD=NULL; #pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wdeprecated-declarations" clGetICDLoaderInfoOCLICD = clGetExtensionFunctionAddress("clGetICDLoaderInfoOCLICD"); #pragma GCC diagnostic pop if (clGetICDLoaderInfoOCLICD == NULL) { printf("No clGetICDLoaderInfoOCLICD function available\n"); return 2; } { char *param_value=NULL; size_t param_value_size_ret=0; #define show(name,NAME) \ do { \ error = clGetICDLoaderInfoOCLICD(CL_ICDL_##NAME, 0, NULL, ¶m_value_size_ret ); \ if (error) { exit(4); } \ param_value = (char *)malloc(param_value_size_ret); \ clGetICDLoaderInfoOCLICD(CL_ICDL_##NAME, param_value_size_ret, param_value, NULL); \ printf(#name ": %s\n",param_value); \ free(param_value); \ param_value=NULL; \ } while (0) show(ocl_version,OCL_VERSION); show(version,VERSION); show(name,NAME); show(vendor,VENDOR); } return 0; } ocl-icd-2.3.3/run_dummy_icd.c000066400000000000000000000062041477331540600160470ustar00rootroot00000000000000/** Copyright (c) 2012-2020, Brice Videau Copyright (c) 2012-2020, Vincent Danjean All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include #include #pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wcpp" # define CL_USE_DEPRECATED_OPENCL_1_0_APIS # define CL_USE_DEPRECATED_OPENCL_1_1_APIS # define CL_USE_DEPRECATED_OPENCL_1_2_APIS # define CL_USE_DEPRECATED_OPENCL_2_0_APIS # define CL_USE_DEPRECATED_OPENCL_2_1_APIS # define CL_USE_DEPRECATED_OPENCL_2_2_APIS # define CL_TARGET_OPENCL_VERSION 300 # include # include # include # include # include #pragma GCC diagnostic pop #include #include "ocl_icd_debug.h" extern void call_all_OpenCL_functions(cl_platform_id chosen_platform); int debug_ocl_icd_mask; int main(void) { int i; cl_uint num_platforms; debug_init(); clGetPlatformIDs( 0, NULL, &num_platforms); cl_platform_id *platforms = malloc(sizeof(cl_platform_id) * num_platforms); clGetPlatformIDs(num_platforms, platforms, NULL); debug(D_LOG, "Found %d platforms.", num_platforms); cl_platform_id chosen_platform=NULL; for(i=0; i'$(srcdir)/package.m4' TESTSUITES_SRC = testsuite.at testsuite-standard.at testsuite-workaround.at testsuite-default-platform.at EXTRA_DIST = $(TESTSUITES_SRC) $(srcdir)/package.m4 $(TESTSUITE) atlocal.in atenv.m4 TESTSUITE = $(srcdir)/testsuite DISTCLEANFILES = atconfig check-local: atconfig atlocal $(TESTSUITE) $(SHELL) '$(TESTSUITE)' $(TESTSUITEFLAGS) installcheck-local: atconfig atlocal $(TESTSUITE) $(SHELL) '$(TESTSUITE)' AUTOTEST_PATH='$(bindir):$(abs_top_builddir)' \ $(TESTSUITEFLAGS) clean-local: test ! -f '$(TESTSUITE)' || \ $(SHELL) '$(TESTSUITE)' --clean AUTOM4TE = $(SHELL) $(top_srcdir)/build-aux/missing --run autom4te AUTOTEST = $(AUTOM4TE) --language=autotest $(TESTSUITE): $(TESTSUITES_SRC) $(srcdir)/package.m4 $(srcdir)/atenv.m4 $(AUTOTEST) -I '$(srcdir)' -o $@.tmp $@.at mv $@.tmp $@ ocl-icd-2.3.3/tests/atenv.m4000066400000000000000000000013571477331540600155720ustar00rootroot00000000000000m4_define([AT_SHOWENV],[dnl m4_if([[$1]],[[]],,[ eval _at_envval='"$'"$1"'"' AS_ECHO(["environment: $1='$(AS_ECHO(["$_at_envval"]) | sed "s/'/'\\\\''/g")'"]) AT_SHOWENV(m4_shift($@))]) ]) m4_define([_AT_SHOWENV_REC],[dnl m4_if([[$1]],[[]],,[ AT_SHOWENV([$1]) _AT_SHOWENV_REC(m4_shift(m4_shift($@)))]) ]) m4_define([_AT_EXPORT_REC],[dnl m4_if([[$1]],[[]],,[ $1=$2 export $1 AS_ECHO(["$at_srcdir/AT_LINE: AS_ESCAPE([[export $1=$2]])"]) _AT_EXPORT_REC(m4_shift(m4_shift($@)))]) ]) m4_define([AT_EXPORT],[dnl _AT_EXPORT_REC($@) _AT_SHOWENV_REC($@) ]) m4_define([AT_UNSET],[dnl m4_if([[$1]],[[]],,[ unset $1 AS_ECHO(["$at_srcdir/AT_LINE: AS_ESCAPE([[unset $1]])"]) AT_UNSET(m4_shift($@))]) ]) ocl-icd-2.3.3/tests/atlocal.in000066400000000000000000000000011477331540600161430ustar00rootroot00000000000000 ocl-icd-2.3.3/tests/testsuite-default-platform.at000066400000000000000000000147301477331540600220350ustar00rootroot00000000000000AT_BANNER([Default platform selection]) AT_SETUP([No choice, among 0 => CL_INVALID_PLATFORM]) AT_EXPORT([OCL_ICD_DEBUG],[15], [OCL_ICD_VENDORS],[unexisting-vendors-dir]) AT_UNSET([OCL_ICD_DEFAULT_PLATFORM]) AT_CHECK([ocl_test --default-platform], 0, [stdout], [stderr]) dnl TODO check errcode when no platforms are available AT_CHECK([cat stdout], 0, [No platforms found! Invalid platform ]) AT_CLEANUP AT_SETUP([Choice 0, among 0 => CL_INVALID_PLATFORM]) AT_EXPORT([OCL_ICD_DEBUG],[15], [OCL_ICD_VENDORS],[unexisting-vendors-dir], [OCL_ICD_DEFAULT_PLATFORM],[0]) AT_CHECK([ocl_test --default-platform], 0, [stdout], [stderr]) AT_CHECK([cat stdout], 0, [No platforms found! Invalid platform ]) AT_CLEANUP AT_SETUP([Choice 1, among 0 => CL_INVALID_PLATFORM]) AT_EXPORT([OCL_ICD_DEBUG],[15], [OCL_ICD_VENDORS],[unexisting-vendors-dir], [OCL_ICD_DEFAULT_PLATFORM],[1]) AT_CHECK([ocl_test --default-platform], 0, [stdout], [stderr]) AT_CHECK([cat stdout], 0, [No platforms found! Invalid platform ]) AT_CLEANUP AT_SETUP([No choice, among 1 => default platform]) AT_EXPORT([OCL_ICD_DEBUG],[7], [OCL_ICD_VENDORS],[$abs_top_builddir/.libs/libdummycl.so]) AT_UNSET([OCL_ICD_DEFAULT_PLATFORM]) AT_CHECK([ocl_test --default-platform], 0, [stdout], [stderr]) AT_CHECK([cat stdout], 0, [Found 1 platforms! ocl-icd ICD test ocl-icd ICD test ]) AT_CLEANUP AT_SETUP([Choice 0, among 1 => default platform]) AT_EXPORT([OCL_ICD_DEBUG],[7], [OCL_ICD_VENDORS],[$abs_top_builddir/.libs/libdummycl.so], [OCL_ICD_DEFAULT_PLATFORM],[0]) AT_CHECK([ocl_test --default-platform], 0, [stdout], [stderr]) AT_CHECK([cat stdout], 0, [Found 1 platforms! ocl-icd ICD test ocl-icd ICD test ]) AT_CLEANUP AT_SETUP([Choice 1, among 1 => CL_INVALID_PLATFORM]) AT_EXPORT([OCL_ICD_DEBUG],[7], [OCL_ICD_VENDORS],[$abs_top_builddir/.libs/libdummycl.so], [OCL_ICD_DEFAULT_PLATFORM],[1]) AT_CHECK([ocl_test --default-platform], 0, [stdout], [stderr]) AT_CHECK([cat stdout], 0, [Found 1 platforms! ocl-icd ICD test Invalid platform ]) AT_CLEANUP AT_SETUP([No choice, among 2 => one platform]) AT_UNSET([OCL_ICD_ASSUME_ICD_EXTENSION]) AT_EXPORT([OCL_ICD_DEBUG],[7], [OCL_ICD_VENDORS],[$abs_top_builddir/vendors]) AT_UNSET([OCL_ICD_DEFAULT_PLATFORM]) AT_CHECK([ocl_test --default-platform], 0, [stdout], [stderr]) dnl platforms can be listed in any order AT_CHECK([env LC_ALL=C sort -u stdout], 0, [Found 2 platforms! ocl-icd ICD test ocl-icd ICD test2 ]) AT_CHECK([wc -l < stdout | sed "s/^ *//"], 0, [4 ]) AT_CLEANUP AT_SETUP([Choice 0, among 2 => first platform]) AT_UNSET([OCL_ICD_ASSUME_ICD_EXTENSION]) AT_EXPORT([OCL_ICD_DEBUG],[7], [OCL_ICD_VENDORS],[$abs_top_builddir/vendors], [OCL_ICD_DEFAULT_PLATFORM],[0]) AT_CHECK([ocl_test --default-platform], 0, [stdout], [stderr]) dnl platforms can be listed in any order AT_CHECK([head -n 2 stdout | tail -n 1 > expout], 0, []) AT_CHECK([tail -n 1 stdout], 0, [expout]) AT_CLEANUP AT_SETUP([Choice 1, among 2 => second platform]) AT_UNSET([OCL_ICD_ASSUME_ICD_EXTENSION]) AT_EXPORT([OCL_ICD_DEBUG],[7], [OCL_ICD_VENDORS],[$abs_top_builddir/vendors], [OCL_ICD_DEFAULT_PLATFORM],[1]) AT_CHECK([ocl_test --default-platform], 0, [stdout], [stderr]) dnl platforms can be listed in any order AT_CHECK([head -n 3 stdout | tail -n 1 > expout], 0, []) AT_CHECK([tail -n 1 stdout], 0, [expout]) AT_CLEANUP AT_SETUP([Choice 2, among 2 => CL_INVALID_PLATFORM]) AT_UNSET([OCL_ICD_ASSUME_ICD_EXTENSION]) AT_EXPORT([OCL_ICD_DEBUG],[7], [OCL_ICD_VENDORS],[$abs_top_builddir/vendors], [OCL_ICD_DEFAULT_PLATFORM],[2]) AT_CHECK([ocl_test --default-platform], 0, [stdout], [stderr]) dnl platforms can be listed in any order AT_CHECK([env LC_ALL=C sort stdout], 0, [Found 2 platforms! Invalid platform ocl-icd ICD test ocl-icd ICD test2 ]) AT_CLEANUP AT_SETUP([Sort by GPU]) AT_UNSET([OCL_ICD_ASSUME_ICD_EXTENSION]) AT_EXPORT([OCL_ICD_DEBUG],[7], [OCL_ICD_VENDORS],[$abs_top_builddir/vendors], [NB_GPU], [31], [NB_GPU2], [3], [NB_CPU], [3], [NB_CPU2], [31], [NB_ALL], [3], [NB_ALL2], [31] ) AT_UNSET([OCL_ICD_DEFAULT_PLATFORM]) AT_CHECK([ocl_test --default-platform], 0, [Found 2 platforms! ocl-icd ICD test ocl-icd ICD test2 ocl-icd ICD test ], [stderr]) AT_CLEANUP AT_SETUP([Sort by GPU (rev)]) AT_UNSET([OCL_ICD_ASSUME_ICD_EXTENSION]) AT_EXPORT([OCL_ICD_DEBUG],[7], [OCL_ICD_VENDORS],[$abs_top_builddir/vendors], [NB_GPU], [3], [NB_GPU2], [31], [NB_CPU], [3], [NB_CPU2], [31], [NB_ALL], [3], [NB_ALL2], [31] ) AT_UNSET([OCL_ICD_DEFAULT_PLATFORM]) AT_CHECK([ocl_test --default-platform], 0, [Found 2 platforms! ocl-icd ICD test2 ocl-icd ICD test ocl-icd ICD test2 ], [stderr]) AT_CLEANUP AT_SETUP([Sort by CPU]) AT_UNSET([OCL_ICD_ASSUME_ICD_EXTENSION]) AT_EXPORT([OCL_ICD_DEBUG],[7], [OCL_ICD_VENDORS],[$abs_top_builddir/vendors], [NB_GPU], [3], [NB_GPU2], [3], [NB_CPU], [31], [NB_CPU2], [3], [NB_ALL], [3], [NB_ALL2], [31] ) AT_UNSET([OCL_ICD_DEFAULT_PLATFORM]) AT_CHECK([ocl_test --default-platform], 0, [Found 2 platforms! ocl-icd ICD test ocl-icd ICD test2 ocl-icd ICD test ], [stderr]) AT_CLEANUP AT_SETUP([Sort by CPU (rev)]) AT_UNSET([OCL_ICD_ASSUME_ICD_EXTENSION]) AT_EXPORT([OCL_ICD_DEBUG],[7], [OCL_ICD_VENDORS],[$abs_top_builddir/vendors], [NB_GPU], [3], [NB_GPU2], [3], [NB_CPU], [3], [NB_CPU2], [31], [NB_ALL], [3], [NB_ALL2], [31] ) AT_UNSET([OCL_ICD_DEFAULT_PLATFORM]) AT_CHECK([ocl_test --default-platform], 0, [Found 2 platforms! ocl-icd ICD test2 ocl-icd ICD test ocl-icd ICD test2 ], [stderr]) AT_CLEANUP AT_SETUP([Sort by devices]) AT_UNSET([OCL_ICD_ASSUME_ICD_EXTENSION]) AT_EXPORT([OCL_ICD_DEBUG],[7], [OCL_ICD_VENDORS],[$abs_top_builddir/vendors], [NB_GPU], [3], [NB_GPU2], [3], [NB_CPU], [31], [NB_CPU2], [31], [NB_ALL], [31], [NB_ALL2], [3] ) AT_UNSET([OCL_ICD_DEFAULT_PLATFORM]) AT_CHECK([ocl_test --default-platform], 0, [Found 2 platforms! ocl-icd ICD test ocl-icd ICD test2 ocl-icd ICD test ], [stderr]) AT_CLEANUP AT_SETUP([Sort by devices (rev)]) AT_UNSET([OCL_ICD_ASSUME_ICD_EXTENSION]) AT_EXPORT([OCL_ICD_DEBUG],[7], [OCL_ICD_VENDORS],[$abs_top_builddir/vendors], [NB_GPU], [3], [NB_GPU2], [3], [NB_CPU], [3], [NB_CPU2], [3], [NB_ALL], [3], [NB_ALL2], [31] ) AT_UNSET([OCL_ICD_DEFAULT_PLATFORM]) AT_CHECK([ocl_test --default-platform], 0, [Found 2 platforms! ocl-icd ICD test2 ocl-icd ICD test ocl-icd ICD test2 ], [stderr]) AT_CLEANUP ocl-icd-2.3.3/tests/testsuite-standard.at000066400000000000000000000064421477331540600203700ustar00rootroot00000000000000AT_BANNER([Standard compliant ocl-icd libOpenCL.so]) AT_SETUP([invalid OCL_ICD_VENDORS]) AT_EXPORT([OCL_ICD_DEBUG],[15], [OCL_ICD_VENDORS],[unexisting-vendors-dir]) AT_CHECK([ocl_test], 0, [No platforms found! ], [stderr]) AT_CLEANUP AT_SETUP([OCL_ICD_VENDORS as directory]) AT_UNSET([OCL_ICD_ASSUME_ICD_EXTENSION]) AT_EXPORT([OCL_ICD_DEBUG],[7], [OCL_ICD_VENDORS],[$abs_top_builddir/vendors]) dnl platforms can be listed in any order AT_CHECK([ocl_test | env LC_ALL=C sort], 0, [Found 2 platforms! ocl-icd ICD test ocl-icd ICD test2 ], [stderr]) AT_CLEANUP AT_SETUP([OCL_ICD_VENDORS as library file]) AT_EXPORT([OCL_ICD_DEBUG],[7], [OCL_ICD_VENDORS],[$abs_top_builddir/.libs/libdummycl.so]) AT_CHECK([ocl_test], 0, [Found 1 platforms! ocl-icd ICD test ], [stderr]) AT_CLEANUP AT_SETUP([OCL_ICD_VENDORS as ICD file (.icd)]) AT_EXPORT([OCL_ICD_DEBUG],[7], [OCL_ICD_VENDORS],[$abs_top_builddir/vendors/dummycl.icd]) AT_CHECK([ocl_test], 0, [Found 1 platforms! ocl-icd ICD test ], [stderr]) AT_CLEANUP AT_SETUP([OPENCL_VENDOR_PATH as directory]) AT_UNSET([OCL_ICD_VENDORS]) AT_EXPORT([OCL_ICD_DEBUG],[7], [OPENCL_VENDOR_PATH],[$abs_top_builddir/vendors]) AT_CHECK([ocl_test | env LC_ALL=C sort], 0, [Found 2 platforms! ocl-icd ICD test ocl-icd ICD test2 ], [stderr]) AT_CLEANUP AT_SETUP([invalid OPENCL_VENDOR_PATH (unknown path)]) AT_UNSET([OCL_ICD_VENDORS]) AT_EXPORT([OCL_ICD_DEBUG],[7], [OPENCL_VENDOR_PATH],[unexisting-vendors-dir]) AT_CHECK([ocl_test], 0, [No platforms found! ], [stderr]) AT_CLEANUP AT_SETUP([invalid OPENCL_VENDOR_PATH (.icd)]) AT_UNSET([OCL_ICD_VENDORS]) AT_EXPORT([OCL_ICD_DEBUG],[7], [OPENCL_VENDOR_PATH],[$abs_top_builddir/vendors/dummycl.icd]) AT_CHECK([ocl_test], 0, [No platforms found! ], [stderr]) AT_CLEANUP AT_SETUP([invalid OPENCL_VENDOR_PATH (library file)]) AT_UNSET([OCL_ICD_VENDORS]) AT_EXPORT([OCL_ICD_DEBUG],[7], [OPENCL_VENDOR_PATH],[$abs_top_builddir/.libs/libdummycl.so]) AT_CHECK([ocl_test], 0, [No platforms found! ], [stderr]) AT_CLEANUP AT_SETUP([OCL_ICD_VENDORS priority over OPENCL_VENDOR_PATH]) AT_UNSET([OCL_ICD_VENDORS]) AT_EXPORT([OCL_ICD_DEBUG],[7], [OCL_ICD_VENDORS],[$abs_top_builddir/vendors/dummycl.icd], [OPENCL_VENDOR_PATH],[$abs_top_builddir/vendors]) AT_CHECK([ocl_test], 0, [Found 1 platforms! ocl-icd ICD test ], [stderr]) AT_CLEANUP AT_SETUP([Our dummy ICD through our ICD loader]) AT_EXPORT([OCL_ICD_DEBUG],[7], [OCL_ICD_VENDORS],[$abs_top_builddir/vendors]) AT_CHECK([run_dummy_icd_through_our_ICDL], 0, [stdout], [stderr]) AT_CHECK([grep "^-1" stdout | sort], 0, []) AT_CHECK([grep -v '^[[0-9]]* *:' stdout ], 0, [--- ]) AT_CHECK([sed -e "s/ *(expected)//" stdout | uniq -c | grep -v '^ *2 ' | sed "s/^ *//" ], 0, [1 --- ]) AT_CLEANUP AT_SETUP([ICD Loader extension]) AT_EXPORT([OCL_ICD_DEBUG],[0], [OCL_ICD_VENDORS],[$abs_top_builddir/vendors]) AT_CHECK([ocl_test_icdl], 0, [ocl_version: OpenCL AT_PACKAGE_OPENCL_VERSION version: AT_PACKAGE_VERSION name: OpenCL ICD Loader vendor: OCL Icd free software ], []) AT_CLEANUP AT_SETUP([Our dummy layer through cllayerinfo]) AT_EXPORT([OPENCL_LAYERS],[$abs_top_builddir/.libs/libdummylayer.so], [OCL_ICD_VENDORS],[$abs_top_builddir/vendors]) AT_CHECK_UNQUOTED([cllayerinfo], 0, [$abs_top_builddir/.libs/libdummylayer.so: CL_LAYER_API_VERSION: 100 CL_LAYER_NAME: dummylayer ], []) AT_CLEANUP ocl-icd-2.3.3/tests/testsuite-workaround.at000066400000000000000000000020541477331540600207560ustar00rootroot00000000000000AT_BANNER([ocl-icd with workaround for intel bug]) AT_SETUP([OCL_ICD_VENDORS as directory, two ICD]) AT_EXPORT([OCL_ICD_ASSUME_ICD_EXTENSION], [1], [OCL_ICD_DEBUG],[7], [OCL_ICD_VENDORS],[$abs_top_builddir/vendors]) AT_CHECK([ocl_test], 0, [stdout], [stderr]) AT_CHECK([env LC_ALL=C sort stdout], 0, [Found 3 platforms! ocl-icd ICD test ocl-icd ICD test (no ext) ocl-icd ICD test2 ]) AT_CLEANUP AT_SETUP([OCL_ICD_VENDORS as file, buggy ICD with workaround]) AT_EXPORT([OCL_ICD_ASSUME_ICD_EXTENSION], [1], [OCL_ICD_DEBUG],[7], [OCL_ICD_VENDORS],[$abs_top_builddir/vendors/dummycl-noext.icd], [EMULATE_INTEL_ICD], [1]) AT_CHECK([ocl_test], 0, [stdout], [stderr]) AT_CHECK([grep "^Found 1 platforms!$" stdout], 0, [ignore]) AT_CHECK([grep "^ocl-icd ICD test (no ext)$" stdout], 0, [ignore]) AT_CLEANUP AT_SETUP([OCL_ICD_VENDORS as file, buggy ICD without workaround]) AT_EXPORT([OCL_ICD_DEBUG],[7], [OCL_ICD_VENDORS],[$abs_top_builddir/vendors/dummycl-noext.icd], [EMULATE_INTEL_ICD], [1]) AT_CHECK([ocl_test], 3, [stdout], [stderr]) AT_CLEANUP ocl-icd-2.3.3/tests/testsuite.at000066400000000000000000000003011477331540600165560ustar00rootroot00000000000000# Testsuite for ocl-icd m4_include([atenv.m4]) AT_INIT() AT_COLOR_TESTS m4_include([testsuite-standard.at]) m4_include([testsuite-default-platform.at]) m4_include([testsuite-workaround.at])