From e98999959390779f2adb90477fcc36b733bb99e4 Mon Sep 17 00:00:00 2001 From: Rom Walton Date: Thu, 31 Mar 2011 21:47:12 +0000 Subject: [PATCH] Quick Updates svn path=/trunk/boinc/; revision=23305 --- coprocs/AMD/include/cal.h | 1087 ++++++++++++++++ coprocs/{CUDA => NVIDIA}/include/nvapi.h | 0 .../NVIDIA/mswin/Win32/Debug/lib/nvapi.lib | Bin 0 -> 10438 bytes .../NVIDIA/mswin/Win32/Release/lib/nvapi.lib | Bin 0 -> 10438 bytes coprocs/NVIDIA/mswin/x64/Debug/lib/nvapi.lib | Bin 0 -> 11006 bytes .../NVIDIA/mswin/x64/Release/lib/nvapi.lib | Bin 0 -> 11006 bytes coprocs/OpenCL/include/cl.h | 1001 +++++++++++++++ coprocs/OpenCL/include/cl_platform.h | 1114 +++++++++++++++++ 8 files changed, 3202 insertions(+) create mode 100644 coprocs/AMD/include/cal.h rename coprocs/{CUDA => NVIDIA}/include/nvapi.h (100%) create mode 100644 coprocs/NVIDIA/mswin/Win32/Debug/lib/nvapi.lib create mode 100644 coprocs/NVIDIA/mswin/Win32/Release/lib/nvapi.lib create mode 100644 coprocs/NVIDIA/mswin/x64/Debug/lib/nvapi.lib create mode 100644 coprocs/NVIDIA/mswin/x64/Release/lib/nvapi.lib create mode 100644 coprocs/OpenCL/include/cl.h create mode 100644 coprocs/OpenCL/include/cl_platform.h diff --git a/coprocs/AMD/include/cal.h b/coprocs/AMD/include/cal.h new file mode 100644 index 0000000000..79c31b1366 --- /dev/null +++ b/coprocs/AMD/include/cal.h @@ -0,0 +1,1087 @@ +/** + * @file cal.h + * @brief CAL Interface Header + * @version 1.00.0 Beta + */ + + +/* ============================================================ + +Copyright (c) 2007 Advanced Micro Devices, Inc. All rights reserved. + +Redistribution and use of this material is permitted under the following +conditions: + +Redistributions must retain the above copyright notice and all terms of this +license. + +In no event shall anyone redistributing or accessing or using this material +commence or participate in any arbitration or legal action relating to this +material against Advanced Micro Devices, Inc. or any copyright holders or +contributors. The foregoing shall survive any expiration or termination of +this license or any agreement or access or use related to this material. + +ANY BREACH OF ANY TERM OF THIS LICENSE SHALL RESULT IN THE IMMEDIATE REVOCATION +OF ALL RIGHTS TO REDISTRIBUTE, ACCESS OR USE THIS MATERIAL. + +THIS MATERIAL IS PROVIDED BY ADVANCED MICRO DEVICES, INC. AND ANY COPYRIGHT +HOLDERS AND CONTRIBUTORS "AS IS" IN ITS CURRENT CONDITION AND WITHOUT ANY +REPRESENTATIONS, GUARANTEE, OR WARRANTY OF ANY KIND OR IN ANY WAY RELATED TO +SUPPORT, INDEMNITY, ERROR FREE OR UNINTERRUPTED OPERATION, OR THAT IT IS FREE +FROM DEFECTS OR VIRUSES. ALL OBLIGATIONS ARE HEREBY DISCLAIMED - WHETHER +EXPRESS, IMPLIED, OR STATUTORY - INCLUDING, BUT NOT LIMITED TO, ANY IMPLIED +WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, +ACCURACY, COMPLETENESS, OPERABILITY, QUALITY OF SERVICE, OR NON-INFRINGEMENT. +IN NO EVENT SHALL ADVANCED MICRO DEVICES, INC. OR ANY COPYRIGHT HOLDERS OR +CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, PUNITIVE, +EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT +OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, REVENUE, DATA, OR PROFITS; OR +BUSINESS INTERRUPTION) HOWEVER CAUSED OR BASED ON ANY THEORY OF LIABILITY +ARISING IN ANY WAY RELATED TO THIS MATERIAL, EVEN IF ADVISED OF THE POSSIBILITY +OF SUCH DAMAGE. THE ENTIRE AND AGGREGATE LIABILITY OF ADVANCED MICRO DEVICES, +INC. AND ANY COPYRIGHT HOLDERS AND CONTRIBUTORS SHALL NOT EXCEED TEN DOLLARS +(US $10.00). ANYONE REDISTRIBUTING OR ACCESSING OR USING THIS MATERIAL ACCEPTS +THIS ALLOCATION OF RISK AND AGREES TO RELEASE ADVANCED MICRO DEVICES, INC. AND +ANY COPYRIGHT HOLDERS AND CONTRIBUTORS FROM ANY AND ALL LIABILITIES, +OBLIGATIONS, CLAIMS, OR DEMANDS IN EXCESS OF TEN DOLLARS (US $10.00). THE +FOREGOING ARE ESSENTIAL TERMS OF THIS LICENSE AND, IF ANY OF THESE TERMS ARE +CONSTRUED AS UNENFORCEABLE, FAIL IN ESSENTIAL PURPOSE, OR BECOME VOID OR +DETRIMENTAL TO ADVANCED MICRO DEVICES, INC. OR ANY COPYRIGHT HOLDERS OR +CONTRIBUTORS FOR ANY REASON, THEN ALL RIGHTS TO REDISTRIBUTE, ACCESS OR USE +THIS MATERIAL SHALL TERMINATE IMMEDIATELY. MOREOVER, THE FOREGOING SHALL +SURVIVE ANY EXPIRATION OR TERMINATION OF THIS LICENSE OR ANY AGREEMENT OR +ACCESS OR USE RELATED TO THIS MATERIAL. + +NOTICE IS HEREBY PROVIDED, AND BY REDISTRIBUTING OR ACCESSING OR USING THIS +MATERIAL SUCH NOTICE IS ACKNOWLEDGED, THAT THIS MATERIAL MAY BE SUBJECT TO +RESTRICTIONS UNDER THE LAWS AND REGULATIONS OF THE UNITED STATES OR OTHER +COUNTRIES, WHICH INCLUDE BUT ARE NOT LIMITED TO, U.S. EXPORT CONTROL LAWS SUCH +AS THE EXPORT ADMINISTRATION REGULATIONS AND NATIONAL SECURITY CONTROLS AS +DEFINED THEREUNDER, AS WELL AS STATE DEPARTMENT CONTROLS UNDER THE U.S. +MUNITIONS LIST. THIS MATERIAL MAY NOT BE USED, RELEASED, TRANSFERRED, IMPORTED, +EXPORTED AND/OR RE-EXPORTED IN ANY MANNER PROHIBITED UNDER ANY APPLICABLE LAWS, +INCLUDING U.S. EXPORT CONTROL LAWS REGARDING SPECIFICALLY DESIGNATED PERSONS, +COUNTRIES AND NATIONALS OF COUNTRIES SUBJECT TO NATIONAL SECURITY CONTROLS. +MOREOVER, THE FOREGOING SHALL SURVIVE ANY EXPIRATION OR TERMINATION OF ANY +LICENSE OR AGREEMENT OR ACCESS OR USE RELATED TO THIS MATERIAL. + +NOTICE REGARDING THE U.S. GOVERNMENT AND DOD AGENCIES: This material is +provided with "RESTRICTED RIGHTS" and/or "LIMITED RIGHTS" as applicable to +computer software and technical data, respectively. Use, duplication, +distribution or disclosure by the U.S. Government and/or DOD agencies is +subject to the full extent of restrictions in all applicable regulations, +including those found at FAR52.227 and DFARS252.227 et seq. and any successor +regulations thereof. Use of this material by the U.S. Government and/or DOD +agencies is acknowledgment of the proprietary rights of any copyright holders +and contributors, including those of Advanced Micro Devices, Inc., as well as +the provisions of FAR52.227-14 through 23 regarding privately developed and/or +commercial computer software. + +This license forms the entire agreement regarding the subject matter hereof and +supersedes all proposals and prior discussions and writings between the parties +with respect thereto. This license does not affect any ownership, rights, title, +or interest in, or relating to, this material. No terms of this license can be +modified or waived, and no breach of this license can be excused, unless done +so in a writing signed by all affected parties. Each term of this license is +separately enforceable. If any term of this license is determined to be or +becomes unenforceable or illegal, such term shall be reformed to the minimum +extent necessary in order for this license to remain in effect in accordance +with its terms as modified by such reformation. This license shall be governed +by and construed in accordance with the laws of the State of Texas without +regard to rules on conflicts of law of any state or jurisdiction or the United +Nations Convention on the International Sale of Goods. All disputes arising out +of this license shall be subject to the jurisdiction of the federal and state +courts in Austin, Texas, and all defenses are hereby waived concerning personal +jurisdiction and venue of these courts. + +============================================================ */ + + + +#ifndef __CAL_H__ +#define __CAL_H__ + +#ifdef __cplusplus +extern "C" { +#define CALAPI +#else +#define CALAPI extern +#endif + +#ifdef _WIN32 +#define CALAPIENTRY __stdcall +#else +#define CALAPIENTRY +#endif + +typedef void CALvoid; /**< void type */ +typedef char CALchar; /**< ASCII character */ +typedef signed char CALbyte; /**< 1 byte signed integer value */ +typedef unsigned char CALubyte; /**< 1 byte unsigned integer value */ +typedef signed short CALshort; /**< 2 byte signed integer value */ +typedef unsigned short CALushort; /**< 2 byte unsigned integer value */ +typedef signed int CALint; /**< 4 byte signed integer value */ +typedef unsigned int CALuint; /**< 4 byte unsigned intger value */ +typedef float CALfloat; /**< 32-bit IEEE floating point value */ +typedef double CALdouble; /**< 64-bit IEEE floating point value */ +typedef signed long CALlong; /**< long value */ +typedef unsigned long CALulong; /**< unsigned long value */ + +#if defined(_MSC_VER) + +typedef signed __int64 CALint64; /**< 8 byte signed integer value */ +typedef unsigned __int64 CALuint64; /**< 8 byte unsigned integer value */ + +#elif defined(__GNUC__) + +typedef signed long long CALint64; /**< 8 byte signed integer value */ +typedef unsigned long long CALuint64; /**< 8 byte unsigned integer value */ + +#else +#error "Unsupported compiler type." +#endif + + + +/** Boolean type */ +typedef enum CALbooleanEnum { + CAL_FALSE = 0, /**< Boolean false value */ + CAL_TRUE = 1 /**< Boolean true value */ +} CALboolean; + +/** Function call result/return codes */ +typedef enum CALresultEnum { + CAL_RESULT_OK = 0, /**< No error */ + CAL_RESULT_ERROR = 1, /**< Operational error */ + CAL_RESULT_INVALID_PARAMETER = 2, /**< Parameter passed in is invalid */ + CAL_RESULT_NOT_SUPPORTED = 3, /**< Function used properly but currently not supported */ + CAL_RESULT_ALREADY = 4, /**< Stateful operation requested has already been performed */ + CAL_RESULT_NOT_INITIALIZED = 5, /**< CAL function was called without CAL being initialized */ + CAL_RESULT_BAD_HANDLE = 6, /**< A handle parameter is invalid */ + CAL_RESULT_BAD_NAME_TYPE = 7, /**< A name parameter is invalid */ + CAL_RESULT_PENDING = 8, /**< An asynchronous operation is still pending */ + CAL_RESULT_BUSY = 9, /**< The resource in question is still in use */ + CAL_RESULT_WARNING = 10, /**< Compiler generated a warning */ +} CALresult; + +/** Data format representation */ +typedef enum CALformatEnum { + CAL_FORMAT_UBYTE_1, /**< A 1 component 8-bit unsigned byte format */ + CAL_FORMAT_UBYTE_2, /**< A 2 component 8-bit unsigned byte format */ + CAL_FORMAT_UBYTE_4, /**< A 4 component 8-bit unsigned byte format */ + CAL_FORMAT_USHORT_1, /**< A 1 component 16-bit unsigned short format */ + CAL_FORMAT_USHORT_2, /**< A 2 component 16-bit unsigned short format */ + CAL_FORMAT_USHORT_4, /**< A 4 component 16-bit unsigned short format */ + CAL_FORMAT_UINT_4, /**< A 4 component 32-bit unsigned integer format */ + CAL_FORMAT_BYTE_4, /**< A 4 component 8-bit byte format */ + CAL_FORMAT_SHORT_1, /**< A 1 component 16-bit short format */ + CAL_FORMAT_SHORT_2, /**< A 2 component 16-bit short format */ + CAL_FORMAT_SHORT_4, /**< A 4 component 16-bit short format */ + CAL_FORMAT_FLOAT_1, /**< A 1 component 32-bit float format */ + CAL_FORMAT_FLOAT_2, /**< A 2 component 32-bit float format */ + CAL_FORMAT_FLOAT_4, /**< A 4 component 32-bit float format */ + CAL_FORMAT_DOUBLE_1, /**< A 1 component 64-bit float format */ + CAL_FORMAT_DOUBLE_2, /**< A 2 component 64-bit float format */ + CAL_FORMAT_UINT_1, /**< A 1 component 32-bit unsigned integer format */ + CAL_FORMAT_UINT_2, /**< A 2 component 32-bit unsigned integer format */ + CAL_FORMAT_BYTE_1, /**< A 1 component 8-bit byte format */ + CAL_FORMAT_BYTE_2, /**< A 2 component 8-bit byte format */ + CAL_FORMAT_INT_1, /**< A 1 component 32-bit signed integer format */ + CAL_FORMAT_INT_2, /**< A 2 component 32-bit signed integer format */ + CAL_FORMAT_INT_4, /**< A 4 component 32-bit signed integer format */ +} CALformat; + +/** Device Kernel ISA */ +typedef enum CALtargetEnum { + CAL_TARGET_600, /**< R600 GPU ISA */ + CAL_TARGET_610, /**< RV610 GPU ISA */ + CAL_TARGET_630, /**< RV630 GPU ISA */ + CAL_TARGET_670, /**< RV670 GPU ISA */ + CAL_TARGET_7XX, /**< R700 class GPU ISA */ + CAL_TARGET_770, /**< RV770 GPU ISA */ + CAL_TARGET_710, /**< RV710 GPU ISA */ + CAL_TARGET_730, /**< RV730 GPU ISA */ +} CALtarget; + +/** CAL object container */ +typedef struct CALobjectRec* CALobject; + +/** CAL image container */ +typedef struct CALimageRec* CALimage; + +typedef CALuint CALdevice; /**< Device handle */ +typedef CALuint CALcontext; /**< context */ +typedef CALuint CALresource; /**< resource handle */ +typedef CALuint CALmem; /**< memory handle */ +typedef CALuint CALfunc; /**< function handle */ +typedef CALuint CALname; /**< name handle */ +typedef CALuint CALmodule; /**< module handle */ +typedef CALuint CALevent; /**< event handle */ + +/** CAL computational domain */ +typedef struct CALdomainRec { + CALuint x; /**< x origin of domain */ + CALuint y; /**< y origin of domain */ + CALuint width; /**< width of domain */ + CALuint height; /**< height of domain */ +} CALdomain; + +/** CAL device information */ +typedef struct CALdeviceinfoRec { + CALtarget target; /**< Device Kernel ISA */ + CALuint maxResource1DWidth; /**< Maximum resource 1D width */ + CALuint maxResource2DWidth; /**< Maximum resource 2D width */ + CALuint maxResource2DHeight; /**< Maximum resource 2D height */ +} CALdeviceinfo; + +/** CAL device attributes */ +typedef struct CALdeviceattribsRec { + CALuint struct_size; /**< Client filled out size of CALdeviceattribs struct */ + CALtarget target; /**< Asic identifier */ + CALuint localRAM; /**< Amount of local GPU RAM in megabytes */ + CALuint uncachedRemoteRAM; /**< Amount of uncached remote GPU memory in megabytes */ + CALuint cachedRemoteRAM; /**< Amount of cached remote GPU memory in megabytes */ + CALuint engineClock; /**< GPU device clock rate in megahertz */ + CALuint memoryClock; /**< GPU memory clock rate in megahertz */ + CALuint wavefrontSize; /**< Wavefront size */ + CALuint numberOfSIMD; /**< Number of SIMDs */ + CALboolean doublePrecision; /**< double precision supported */ + CALboolean localDataShare; /**< local data share supported */ + CALboolean globalDataShare; /**< global data share supported */ + CALboolean globalGPR; /**< global GPR supported */ + CALboolean computeShader; /**< compute shader supported */ + CALboolean memExport; /**< memexport supported */ + CALuint pitch_alignment; /**< Required alignment for calCreateRes allocations (in data elements) */ + CALuint surface_alignment; /**< Required start address alignment for calCreateRes allocations (in bytes) */ +} CALdeviceattribs; + +/** CAL device status */ +typedef struct CALdevicestatusRec { + CALuint struct_size; /**< Client filled out size of CALdevicestatus struct */ + CALuint availLocalRAM; /**< Amount of available local GPU RAM in megabytes */ + CALuint availUncachedRemoteRAM; /**< Amount of available uncached remote GPU memory in megabytes */ + CALuint availCachedRemoteRAM; /**< Amount of available cached remote GPU memory in megabytes */ +} CALdevicestatus; + +/** CAL resource allocation flags **/ +typedef enum CALresallocflagsEnum { + CAL_RESALLOC_GLOBAL_BUFFER = 1, /**< used for global import/export buffer */ + CAL_RESALLOC_CACHEABLE = 2, /**< cacheable memory? */ +} CALresallocflags; + +/** CAL computational 3D domain */ +typedef struct CALdomain3DRec { + CALuint width; /**< width of domain */ + CALuint height; /**< height of domain */ + CALuint depth; /**< depth of domain */ +} CALdomain3D; + +/** CAL computational grid */ +typedef struct CALprogramGridRec { + CALfunc func; /**< CALfunc to execute */ + CALdomain3D gridBlock; /**< size of a block of data */ + CALdomain3D gridSize; /**< size of 'blocks' to execute. */ + CALuint flags; /**< misc grid flags */ +} CALprogramGrid; + +/** CAL computational grid array*/ +typedef struct CALprogramGridArrayRec { + CALprogramGrid* gridArray;/**< array of programGrid structures */ + CALuint num; /**< number of entries in the grid array */ + CALuint flags; /**< misc grid array flags */ +} CALprogramGridArray; + +/** CAL function information **/ +typedef struct CALfuncInfoRec +{ + CALuint maxScratchRegsNeeded; /**< Maximum number of scratch regs needed */ + CALuint numSharedGPRUser; /**< Number of shared GPRs */ + CALuint numSharedGPRTotal; /**< Number of shared GPRs including ones used by SC */ + CALboolean eCsSetupMode; /**< Slow mode */ + CALuint numThreadPerGroup; /**< Number of threads per group */ + CALuint totalNumThreadGroup; /**< Total number of thread groups */ + CALuint wavefrontPerSIMD; /**< Number of wavefronts per SIMD */ //CAL_USE_SC_PRM + CALuint numWavefrontPerSIMD; /**< Number of wavefronts per SIMD */ + CALboolean isMaxNumWavePerSIMD; /**< Is this the max num active wavefronts per SIMD */ + CALboolean setBufferForNumGroup; /**< Need to set up buffer for info on number of thread groups? */ +} CALfuncInfo; + +/*============================================================================ + * CAL Runtime Interface + *============================================================================*/ + +/*---------------------------------------------------------------------------- + * CAL Subsystem Functions + *----------------------------------------------------------------------------*/ + +/** + * @fn calInit(void) + * + * @brief Initialize the CAL subsystem. + * + * Initializes the CAL system for computation. The behavior of CAL methods is + * undefined if the system is not initialized. + * + * @return Returns CAL_RESULT_OK on success, CAL_RESULT_ERROR if there was an error, and CAL_RESULT_ALREADY + * of CAL has already been initialized. + * + * @sa calShutdown + */ +CALAPI CALresult CALAPIENTRY calInit(void); + + +/** + * @fn calGetVersion(CALuint* major, CALuint* minor, CALuint* imp) + * + * @brief Retrieve the CAL version that is loaded + * + * CAL version is in the form of API_Major.API_Minor.Implementation where + * "API_Major" is the major version number of the CAL API. "API_Minor" is the + * minor version number of the CAL API. "Implementation" is the implementation + * instance of the supplied API version number. + * + * @return Returns CAL_RESULT_OK on success. + * + * @sa calInit calShutdown + */ +CALAPI CALresult CALAPIENTRY calGetVersion(CALuint* major, CALuint* minor, CALuint* imp); + +/** + * @fn calShutdown(void) + * + * @brief Shuts down the CAL subsystem. + * + * Shuts down the CAL system. calShutdown should always be paired with + * calInit. An application may have any number of calInit - calShutdown + * pairs. Any CAL call outsied calInit - calShutdown pair will return + * CAL_RESULT_NOT_INITIALIZED. + * + * @return Returns CAL_RESULT_OK on success, CAL_RESULT_ERROR if there was an error. + * + * @sa calInit + */ +CALAPI CALresult CALAPIENTRY calShutdown(void); + + +/*---------------------------------------------------------------------------- + * CAL Device Functions + *----------------------------------------------------------------------------*/ + +/** + * @fn calDeviceGetCount(CALuint* count) + * + * @brief Retrieve the number of devices available to the CAL subsystem. + * + * Returns in *count the total number of supported GPUs present in the system. + * + * @param count (out) - the number of devices available to CAL. On error, count will be zero. + * + * @return Returns CAL_RESULT_OK on success, CAL_RESULT_ERROR if there was an error. + * + * @sa calDeviceGetInfo calDeviceOpen calDeviceClose + */ +CALAPI CALresult CALAPIENTRY calDeviceGetCount(CALuint* count); + +/** + * @fn calDeviceGetInfo(CALdeviceinfo* info, CALuint ordinal) + * + * @brief Retrieve information about a specific device available to the CAL subsystem. + * + * Returns the device specific information in *info. calDeviceGetInfo returns + * CAL_RESULT_ERROR if the ordinal is not less than the *count returned in + * calDeviceGetCount. The target instruction set, the maximum width of + * 1D resources, the maximum width and height of 2D resources are part + * of the CALdeviceinfo structure. + * + * @param info (out) - the device descriptor struct for the specified device. + * @param ordinal (in) - zero based index of the device to retrieve information. + * + * @return Returns CAL_RESULT_OK on success, CAL_RESULT_ERROR if there was an error. + * + * @sa calDeviceGetCount calDeviceOpen calDeviceClose + */ +CALAPI CALresult CALAPIENTRY calDeviceGetInfo(CALdeviceinfo* info, CALuint ordinal); + +/** + * @fn calDeviceGetAttribs(CALdeviceattribs* attribs, CALuint ordinal) + * + * @brief Retrieve information about a specific device available to the CAL subsystem. + * + * Returns the device specific attributes in *attribs. calDeviceGetAttribs returns + * CAL_RESULT_ERROR if the ordinal is not less than the *count returned in + * calDeviceGetCount. + * + * @param attribs (out) - the device attribute struct for the specified device. + * @param ordinal (in) - zero based index of the device to retrieve information. + * + * @return Returns CAL_RESULT_OK on success, CAL_RESULT_ERROR if there was an error. + * + * @sa calDeviceGetCount calDeviceOpen calDeviceClose + */ +CALAPI CALresult CALAPIENTRY calDeviceGetAttribs(CALdeviceattribs* attribs, CALuint ordinal); + + +/** + * @fn calDeviceGetStatus(CALdevicestatus* status, CALdevice device) + * + * @brief Retrieve information about a specific device available to the CAL subsystem. + * + * Returns the current status of an open device in *status. + * + * @param status (out) - the status struct for the specified device. + * @param device (in) - handle of the device from which status is to be retrieved. + * + * @return Returns CAL_RESULT_OK on success, CAL_RESULT_ERROR if there was an error. + * + * @sa calDeviceGetAttribs calDeviceOpen calDeviceClose + */ +CALAPI CALresult CALAPIENTRY calDeviceGetStatus(CALdevicestatus* status, CALdevice device); + +/** + * @fn calDeviceOpen(CALdevice* dev, CALuint ordinal) + * + * @brief Open the specified device. + * + * Opens a device. A device has to be closed before it can be opened again in + * the same application. This call should always be paired with calDeviceClose. + * Open the device indexed by the ordinal parameter, which + * is an unsigned integer in the range of zero to the number of available devices (minus one). + * + * @param dev (out) - the device handle for the specified device. On error, dev will be zero. + * @param ordinal (in) - zero based index of the device to retrieve information. + * + * @return Returns CAL_RESULT_OK on success, CAL_RESULT_ERROR if there was an error. + * + * @sa calDeviceGetCount calDeviceGetInfo calDeviceClose + */ +CALAPI CALresult CALAPIENTRY calDeviceOpen(CALdevice* dev, CALuint ordinal); + +/** + * @fn calDeviceClose(CALdevice dev) + * + * @brief Close the specified device. + * + * Close the device specified by dev parameter. The + * + * @param dev (in) - the device handle for the device to close + * + * @return Returns CAL_RESULT_OK on success, CAL_RESULT_ERROR if there was an error. + * + * @sa calDeviceGetCount calDeviceGetInfo calDeviceOpen + */ +CALAPI CALresult CALAPIENTRY calDeviceClose(CALdevice dev); + + +/*---------------------------------------------------------------------------- + * CAL Resource Functions + *----------------------------------------------------------------------------*/ + +/** + * @fn calResAllocLocal2D(CALresource* res, CALdevice dev, CALuint width, CALuint height, CALformat format, CALuint flags) + * + * @brief Allocate a memory resource local to a device + * + * allocates memory resource local to a device dev and returns a + * resource handle in *res if successful. This memory is structured + * as a 2 dimensional region of width and height with a format. + * The maximum values of width and height are available through + * the calDeviceGetInfo function. The call returns CAL_RESULT_ERROR if requested + * memory was not available. + * + * Initial implementation will allow this memory to be accessible by all contexts + * created on this device only. Contexts residing on other devices cannot access + * this memory. + * + * flags can be zero or CAL_RESALLOC_GLOBAL_BUFFER + * - to specify that the resource will be used as a global + * buffer. + * + * There are some performance implications when width is not a multiple + * of 64 for R6xx GPUs. + * + * @param res (out) - returned resource handle. On error, res will be zero. + * @param dev (in) - device the resource should be local. + * @param width (in) - width of resource (in elements). + * @param height (in) - height of the resource (in elements). + * @param format (in) - format/type of each element of the resource. + * @param flags (in) - currently unused. + * + * @return Returns CAL_RESULT_OK on success, CAL_RESULT_ERROR if there was an error. + * + * @sa calResFree + */ +CALAPI CALresult CALAPIENTRY calResAllocLocal2D(CALresource* res, CALdevice dev, CALuint width, CALuint height, CALformat format, CALuint flags); + +/** + * @fn calResAllocRemote2D(CALresource* res, CALdevice* dev, CALuint devCount, CALuint width, CALuint height, CALformat format, CALuint flags) + * + * @brief Allocate a memory resource remote to a set of devices + * + * allocates memory resource global to devCount number of devices in dev array + * and returns a resource handle in *res if successful. This memory is structured + * as a 2 dimensional region of width and height with a format. + * The maximum values of width and height are available through + * the calDeviceGetInfo function. The call returns CAL_RESULT_ERROR if requested + * memory was not available. + * + * Currently only a single device is functional (devCount must be 1). + * + * Initial implementation will allow this memory to be accessible by all contexts + * created on this device only. Contexts residing on other devices cannot access + * this memory. + * + * flags can be zero or CAL_RESALLOC_GLOBAL_BUFFER - to + * specify that the resource will be used as a global buffer or + * CAL_RESALLOC_CACHEABLE for GART cacheable memory. + * + * One of the benefits with devices being able to write to remote (i.e. system) + * memory is performance. For example, with large computational kernels, it is + * sometimes faster for the GPU contexts to write directly to remote + * memory than it is to do these in 2 steps of GPU context writing to local memory + * and copying data from GPU local memory to remote system memory via calMemCopy + * + * @param res (out) - returned resource handle. On error, res will be zero. + * @param dev (in) - list of devices the resource should be available to. + * @param devCount (in) - number of devices in the device list. + * @param width (in) - width of resource (in elements). + * @param height (in) - height of the resource (in elements). + * @param format (in) - format/type of each element of the resource. + * @param flags (in) - currently unused. + * + * @return Returns CAL_RESULT_OK on success, CAL_RESULT_ERROR if there was an error. + * + * @sa calResFree + */ +CALAPI CALresult CALAPIENTRY calResAllocRemote2D(CALresource* res, CALdevice *dev, CALuint deviceCount, CALuint width, CALuint height, CALformat format, CALuint flags); + +/** + * @fn calResAllocLocal1D(CALresource* res, CALdevice dev, CALuint width, CALformat format, CALuint flags) + * + * @brief Allocate a 1D memory resource local to a device + * + * allocates memory resource local to a device device and returns + * a resource handle in *res if successful. This memory is + * structured as a 1 dimensional array of width elements with a format}. + * The maximum values of width is available from the calDeviceGetInfo function. + * The call returns CAL_RESULT_ERROR if requested memory was not available. + * + * @param res (out) - returned resource handle. On error, res will be zero. + * @param dev (in) - device the resource should be local. + * @param width (in) - width of resource (in elements). + * @param format (in) - format/type of each element of the resource. + * @param flags (in) - currently unused. + * + * @return Returns CAL_RESULT_OK on success, CAL_RESULT_ERROR if there was an error. + * + * @sa calResFree + */ +CALAPI CALresult CALAPIENTRY calResAllocLocal1D(CALresource* res, CALdevice dev, CALuint width, CALformat format, CALuint flags); + +/** + * @fn calResAllocRemote1D(CALresource* res, CALdevice* dev, CALuint deviceCount, CALuint width, CALformat format, CALuint flags) + * + * @brief Allocate a 1D memory resource remote to a device + * + * allocates memory resource global to devCount number of devices + * in dev array and returns a resource memory handle in *res if + * successful. This memory resource is structured as a 1 dimensional + * region of width elements with a format. The maximum values of + * width is available from the calDeviceGetInfo function. The call returns + * CAL_RESULT_ERROR if requested memory was not available. + * + * Currently only a single device is functional (devCount must be 1). + * + * @param res (out) - returned resource handle. On error, res will be zero. + * @param dev (in) - device the resource should be local. + * @param deviceCount (in) - number of devices in the device list. + * @param width (in) - width of resource (in elements). + * @param format (in) - format/type of each element of the resource. + * @param flags (in) - currently unused. + * + * @return Returns CAL_RESULT_OK on success, CAL_RESULT_ERROR if there was an error. + * + * @sa calResFree + */ +CALAPI CALresult CALAPIENTRY calResAllocRemote1D(CALresource* res, CALdevice* dev, CALuint deviceCount, CALuint width, CALformat format, CALuint flags); + +/** + * @fn calResFree(CALresource res) + * + * @brief Free a resource + * + * releases allocated memory resource. calResFree returns CAL_RESULT_BUSY if + * the resources is in use by any context. + * + * @param res (in) - resource handle to free. + * + * @return Returns CAL_RESULT_OK on success, CAL_RESULT_ERROR if there was an error. + * + * @sa calResAllocLocal2D calResAllocRemote2D calResAllocLocal1D calResAllocRemote1D + */ +CALAPI CALresult CALAPIENTRY calResFree(CALresource res); + +/** + * @fn calResMap(CALvoid** pPtr, CALuint* pitch, CALresource res, CALuint flags) + * + * @brief Map memory to the CPU + * + * + * returns a CPU accessible pointer to the memory surface in **pPtr + * and the pitch in *pitch. All memory resources are CPU accessible. It is an + * error to call calResMap within a calResMap - calResUnmap pair + * for the same CALresource memory resource handle. + * + * A mapped surface cannot be used as input or output of a calCtxRunProgram or calMemCopy. + * + * @param pPtr (out) - CPU pointer to the mapped resource. On error, pPtr will be zero. + * @param pitch (out) - Pitch in elements of the resource. On error, pitch will be zero. + * @param res (in) - resource handle to map + * @param flags (in) - not used + * + * @return Returns CAL_RESULT_OK on success, CAL_RESULT_ERROR if there was an error. + * + * @sa calResUnmap + */ +CALAPI CALresult CALAPIENTRY calResMap(CALvoid** pPtr, CALuint* pitch, CALresource res, CALuint flags); + +/** + * @fn calResUnmap(CALresource res) + * + * @brief Unmap a CPU mapped resource. + * + * releases the address returned in calResMap. This should always be + * paired with calResMap + * + * @param res (in) - resource handle to unmap + * + * @return Returns CAL_RESULT_OK on success, CAL_RESULT_ERROR if there was an error. + * + * @sa calResMap + */ +CALAPI CALresult CALAPIENTRY calResUnmap(CALresource res); + + +/*---------------------------------------------------------------------------- + * CAL Context Functions + *----------------------------------------------------------------------------*/ + +/** + * @fn calCtxCreate(CALcontext* ctx, CALdevice dev) + * + * @brief Create a CAL context on the specified device + * + * creates a context on a device. Multiple contexts can be created on + * a single device. + * + * @param ctx (out) - handle of the newly created context. On error, ctx will be zero. + * @param dev (in) - device handle to create the context on + * + * @return Returns CAL_RESULT_OK on success, CAL_RESULT_ERROR if there was an error. + * + * @sa calCtxDestroy + */ +CALAPI CALresult CALAPIENTRY calCtxCreate(CALcontext* ctx, CALdevice dev); + +/** + * @fn calCtxDestroy(CALcontext ctx) + * + * @brief Destroy a CAL context + * + * destroys a context. All current modules are unloaded and all CALmem objects + * mapped to the context are released. This call should be paired with + * calCtxCreate + * + * @param ctx (in) - context to destroy + * + * @return Returns CAL_RESULT_OK on success, CAL_RESULT_ERROR if there was an error. + * + * @sa calCtxCreate + */ +CALAPI CALresult CALAPIENTRY calCtxDestroy(CALcontext ctx); + +/** + * @fn calCtxGetMem(CALmem* mem, CALcontext ctx, CALresource res) + * + * @brief Map a resource to a context + * + * returns a memory handle in *mem for the resource surface res + * for use by the context ctx. + * + * @param mem (out) - created memory handle. On error, mem will be zero. + * @param ctx (in) - context in which resouce is mapped + * @param res (in) - resource to map to context + * + * @return Returns CAL_RESULT_OK on success, CAL_RESULT_ERROR if there was an error. + * + * @sa calCtxReleaseMem calCtxSetMem + */ +CALAPI CALresult CALAPIENTRY calCtxGetMem(CALmem* mem, CALcontext ctx, CALresource res); + +/** + * @fn calCtxReleaseMem(CALcontext ctx, CALmem mem) + * + * @brief Release a resource to context mapping + * + * releases memory handle mem that is obtained by calCtxGetMem. + * + * @param ctx (in) - context in which resouce is mapped + * @param mem (in) - memory handle to release + * + * @return Returns CAL_RESULT_OK on success, CAL_RESULT_ERROR if there was an error. + * + * @sa calCtxGetMem calCtxSetMem + */ +CALAPI CALresult CALAPIENTRY calCtxReleaseMem(CALcontext ctx, CALmem mem); + +/** + * @fn calCtxSetMem(CALcontext ctx, CALname name, CALmem mem) + * + * @brief Set memory used for kernel input or output + * + * sets a memory handle mem with the associated name in + * the module to the context ctx. This can be input or output. + * + * @param ctx (in) - context to apply attachment. + * @param name (in) - name to bind memory. + * @param mem (in) - memory handle to apply. + * + * @return Returns CAL_RESULT_OK on success, CAL_RESULT_ERROR if there was an error. + * + * @sa calCtxGetMem calCtxReleaseMem + */ +CALAPI CALresult CALAPIENTRY calCtxSetMem(CALcontext ctx, CALname name, CALmem mem); + +/** + * @fn calCtxRunProgram(CALevent* event, CALcontext ctx, CALfunc func, const CALdomain* domain) + * + * @brief Invoke the kernel over the specified domain. + * + * + * issues a task to invoke the computation of the kernel identified by + * func within a region domain on the context ctx and + * returns an associated event token in *event with this task. This + * method returns CAL_RESULT_ERROR if func is not found in the currently + * loaded module. This method returns CAL_RESULT_ERROR, if any of the inputs, + * input references, outputs and constant buffers associated with the kernel + * are not setup. Completion of this event can be queried by the master process + * using calIsEventDone + * + * Extended contextual information regarding a calCtxRunProgram failure + * can be obtained with the calGetErrorString function. + * + * @param event (out) - event associated with RunProgram instance. On error, event will be zero. + * @param ctx (in) - context. + * @param func (in) - function to use as kernel. + * @param domain (in) - domain over which kernel is applied. + * + * @return Returns CAL_RESULT_OK on success, CAL_RESULT_ERROR if there was an error. + * + * @sa calCtxIsEventDone + */ +CALAPI CALresult CALAPIENTRY calCtxRunProgram(CALevent* event, CALcontext ctx, CALfunc func, const CALdomain* domain); + +/** + * @fn calCtxIsEventDone(CALcontext ctx, CALevent event) + * + * @brief Query to see if event has completed + * + * + * is a mechanism for the master process to query if an event event on + * context ctx from calCtxRunProgram or calMemCopy is + * completed. This call also ensures that the commands associated with + * the context are flushed. + * + * @param ctx (in) - context to query. + * @param event (in) - event to query. + * + * @return Returns CAL_RESULT_OK if the event is complete, CAL_RESULT_PENDING if the event is + * still being processed and CAL_RESULT_ERROR if there was an error. + * + * @sa calCtxRunProgram + */ +CALAPI CALresult CALAPIENTRY calCtxIsEventDone(CALcontext ctx, CALevent event); + +/** + * @fn calCtxFlush(CALcontext ctx) + * + * @brief Flush any commands associated with the supplied context + * + * This call ensures that the commands associated with the + * context are flushed. + * + * @param ctx (in) - context to flush. + * + * @return Returns CAL_RESULT_OK if the event is complete, CAL_RESULT_ERROR if + * there was an error. + * + * @sa calCtxRunProgram calCtxIsEventDone + */ +CALAPI CALresult CALAPIENTRY calCtxFlush(CALcontext ctx); + +/** + * @fn calMemCopy(CALevent* event, CALcontext ctx, CALmem srcMem, CALmem dstMem, CALuint flags) + * + * @brief Copy srcMem to dstMem + * + * issues a task to copy data from a source memory handle to a + * destination memory handle. This method returns CAL_RESULT_ERROR if the source + * and destination memory have different memory formats or if the destination + * memory handle is not as big in 2 dimensions as the source memory or + * if the source and destination memory handles do not belong to the + * context ctx. An event is associated with this task and is returned in + * *event and completion of this event can be queried by the master + * process using calIsEventDone. Data can be copied between memory + * handles from remote system memory to device local memory, remote system + * memory to remote system memory, device local memory to remote + * system memory, device local memory to same device local memory, device + * local memory to a different device local memory. The memory is copied by + * the context ctx + * + * @param event (out) - event associated with Memcopy instance. On error, event will be zero. + * @param ctx (in) - context to query. + * @param srcMem (in) - source of the copy. + * @param dstMem (in) - destination of the copy. + * @param flags (in) - currently not used. + * + * @return Returns CAL_RESULT_OK on success, CAL_RESULT_ERROR if there was an error. + * + * @sa calCtxRunProgram + */ +CALAPI CALresult CALAPIENTRY calMemCopy(CALevent* event, CALcontext ctx, CALmem srcMem, CALmem dstMem, CALuint flags); + +/*---------------------------------------------------------------------------- + * CAL Image Functions + *----------------------------------------------------------------------------*/ + +/** + * @fn calImageRead(CALimage* image, const CALvoid* buffer, CALuint size) + * + * @brief Create a CALimage and serialize into it from the supplied buffer. + * + * Create a CALimage and populate it with information from the supplied buffer. + * + * @param image (out) - image created from serialization + * @param buffer (in) - buffer to serialize from + * @param size (in) - size of buffer + * + * @return Returns CAL_RESULT_OK on success, CAL_RESULT_ERROR if there was an error. + * @sa calImageFree + */ +CALAPI CALresult CALAPIENTRY calImageRead(CALimage *image, const CALvoid* buffer, CALuint size); + +/** + * @fn calImageFree(CALimage image) + * + * @brief Free the supplied CALimage. + * + * Free a calImage that was created with calImageRead. + * + * @param image (in) - image to free + * + * @return Returns CAL_RESULT_OK on success, CAL_RESULT_ERROR if there was an error. + * + * @sa calImageRead + */ +CALAPI CALresult CALAPIENTRY calImageFree(CALimage image); + +/*---------------------------------------------------------------------------- + * CAL Module Functions + *----------------------------------------------------------------------------*/ + +/** + * @fn calModuleLoad(CALmodule* module, CALcontext ctx, CALimage image) + * + * @brief Load a kernel image to a context + * + * creates a module from precompiled image image, loads the module + * on the context and returns the loaded module in *module. This + * method returns CAL_RESULT_ERROR if the module cannot be loaded onto the + * processor. One of the reasons why a module cannot be loaded is if the + * module does not have generated ISA for the hardware that it is loaded + * onto. Multiple images can be loaded onto a single context at any single time. + * + * @param module (out) - handle to the loaded image. On error, module will be zero. + * @param ctx (in) - context to load an image. + * @param image (in) - raw image to load. + * + * @return Returns CAL_RESULT_OK on success, CAL_RESULT_ERROR if there was an error. + * + * @sa calModuleUnload calModuleGetEntry calModuleGetName + */ +CALAPI CALresult CALAPIENTRY calModuleLoad(CALmodule* module, CALcontext ctx, CALimage image); + +/** + * @fn calModuleUnload(CALcontext ctx, CALmodule module) + * + * @brief Unload a kernel image + * + * unloads the module from the context. + * + * @param ctx (in) - context. + * @param module (in) - handle to the loaded image. + * + * @return Returns CAL_RESULT_OK on success, CAL_RESULT_ERROR if there was an error. + * + * @sa calModuleLoad calModuleGetEntry calModuleGetName + */ +CALAPI CALresult CALAPIENTRY calModuleUnload(CALcontext ctx, CALmodule module); + +/** + * @fn calModuleGetEntry(CALfunc* func, CALcontext ctx, CALmodule module, const CALchar* procName) + * + * @brief Retrieve a kernel function + * + * returns in *func the entry point to the kernel function named + * procName from the module module. This method returns + * CAL_RESULT_ERROR if the entry point procName is not found in the module. + * + * @param func (out) - handle to kernel function. On error, func will be zero. + * @param ctx (in) - context. + * @param module (in) - handle to the loaded image. + * @param procName (in) - name of the function. + * + * @return Returns CAL_RESULT_OK on success, CAL_RESULT_ERROR if there was an error. + * + * @sa calModuleLoad calModuleUnload calModuleGetEntry + */ +CALAPI CALresult CALAPIENTRY calModuleGetEntry(CALfunc* func, CALcontext ctx, CALmodule module, const CALchar* procName); + +/** + * @fn calModuleGetName(CALname* name, CALcontext ctx, CALmodule module, const CALchar* varName) + * + * @brief Retrieve a kernel parameter by name + * + * returns in *name the handle to the module global variable named + * varName that can be used to setup inputs and constant buffers to + * the kernel computation. This method returns CAL_RESULT_ERROR if the variable + * varName is not found in the module. + * + * @param name (out) - handle to name symbol. On error, name will be zero. + * @param ctx (in) - context. + * @param module (in) - handle to the loaded image. + * @param varName (in) - name of the input or output. + * + * @return Returns CAL_RESULT_OK on success, CAL_RESULT_ERROR if there was an error. + * + * @sa calModuleLoad calModuleUnload calModuleGetEntry + */ +CALAPI CALresult CALAPIENTRY calModuleGetName(CALname* name, CALcontext ctx, CALmodule module, const CALchar* varName); + +/*---------------------------------------------------------------------------- + * CAL Error/Debug Helper Functions + *----------------------------------------------------------------------------*/ +/** + * @fn calGetErrorString(void) + * + * @brief Return details about current error state + * + * calGetErrorString returns a text string containing details about the last + * returned error condition. Calling calGetErrorString does not effect the + * error state. + * + * @return Returns a null terminated string detailing the error condition + * + * @sa calInit calShutdown + */ +CALAPI const CALchar* CALAPIENTRY calGetErrorString(void); + +/** + * @fn calCtxRunProgramGrid(CALevent* event, CALcontext ctx, CALprogramGrid* pProgramGrid) + * + * @brief Invoke the kernel over the specified domain. + * + * + * issues a task to invoke the computation of the kernel identified by + * func within a region domain on the context ctx and + * returns an associated event token in *event with this task. This + * method returns CAL_RESULT_ERROR if func is not found in the currently + * loaded module. This method returns CAL_RESULT_ERROR, if any of the inputs, + * input references, outputs and constant buffers associated with the kernel + * are not setup. Completion of this event can be queried by the master process + * using calIsEventDone + * + * Extended contextual information regarding a calCtxRunProgram failure + * can be obtained with the calGetErrorString function. + * + * @param event (out) - event associated with RunProgram instance. On error, event will be zero. + * @param ctx (in) - context. + * @param pProgramGrid (in) - description of program information to get kernel and thread counts. + * + * @return Returns CAL_RESULT_OK on success, CAL_RESULT_ERROR if there was an error. + * + * @sa calCtxIsEventDone + */ +CALAPI CALresult CALAPIENTRY calCtxRunProgramGrid(CALevent* event, + CALcontext ctx, + CALprogramGrid* pProgramGrid); + +/** + * @fn calModuleGetFuncInfo(CALfuncInfo* pInfo, CALcontext ctx, CALmodule module, CALfunc func) + * + * @brief Retrieve information regarding the named func in the + * named module. + * + * returns in *info the information regarding the func. + * This method returns CAL_RESULT_NOT_INITIALIZED if CAL is not + * initialied. + * This method returns CAL_RESULT_INVALID_PARAMETER if info is + * NULL. + * This method returns CAL_RESULT_BAD_HANDLE if ctx is invalid + * or module is not loaded or func is not found. + * This method returns CAL_RESULT_ERROR if there was an error + * + * @param pInfo (out) - pointer to CALmoduleInfo output + * structure. + * @param ctx (in) - context. + * @param module (in) - handle to the loaded image. + * @param func (in) - name of the function. + * + * @return Returns CAL_RESULT_OK on success, + * CAL_RESULT_NOT_INITIALIZED, + * CAL_RESULT_INVALID_PARAMETER, CAL_RESULT_BAD_HANDLE, + * or CAL_RESULT_ERROR if there was an error. + * + */ +CALAPI CALresult CALAPIENTRY calModuleGetFuncInfo(CALfuncInfo* pInfo, + CALcontext ctx, + CALmodule module, + CALfunc func); + +/** + * @fn calCtxRunProgramGridArray(CALevent* event, CALcontext ctx, CALprogramGridArray* pGridArray) + * + * @brief Invoke the kernel array over the specified domain(s). + * + * + * issues a task to invoke the computation of the kernel arrays identified by + * func within a region domain on the context ctx and + * returns an associated event token in *event with this task. This + * method returns CAL_RESULT_ERROR if func is not found in the currently + * loaded module. This method returns CAL_RESULT_ERROR, if any of the inputs, + * input references, outputs and constant buffers associated with the kernel + * are not setup. Completion of this event can be queried by the master process + * using calIsEventDone + * + * Extended contextual information regarding a calCtxRunProgram failure + * can be obtained with the calGetErrorString function. + * + * @param event (out) - event associated with RunProgram instance. On error, event will be zero. + * @param ctx (in) - context. + * @param pGridArray (in) - array containing kernel programs and grid information. + * + * @return Returns CAL_RESULT_OK on success, CAL_RESULT_ERROR if there was an error. + * + * @sa calCtxIsEventDone + */ +CALAPI CALresult CALAPIENTRY calCtxRunProgramGridArray(CALevent* event, + CALcontext ctx, + CALprogramGridArray* pGridArray); +#ifdef __cplusplus +} /* extern "C" { */ +#endif + + +#endif /* __CAL_H__ */ + + + diff --git a/coprocs/CUDA/include/nvapi.h b/coprocs/NVIDIA/include/nvapi.h similarity index 100% rename from coprocs/CUDA/include/nvapi.h rename to coprocs/NVIDIA/include/nvapi.h diff --git a/coprocs/NVIDIA/mswin/Win32/Debug/lib/nvapi.lib b/coprocs/NVIDIA/mswin/Win32/Debug/lib/nvapi.lib new file mode 100644 index 0000000000000000000000000000000000000000..6e88340b5352dbc64e90a39648c58cb63ee88510 GIT binary patch literal 10438 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 literal 0 HcmV?d00001 diff --git a/coprocs/NVIDIA/mswin/Win32/Release/lib/nvapi.lib b/coprocs/NVIDIA/mswin/Win32/Release/lib/nvapi.lib new file mode 100644 index 0000000000000000000000000000000000000000..6e88340b5352dbc64e90a39648c58cb63ee88510 GIT binary patch literal 10438 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 literal 0 HcmV?d00001 diff --git a/coprocs/NVIDIA/mswin/x64/Debug/lib/nvapi.lib b/coprocs/NVIDIA/mswin/x64/Debug/lib/nvapi.lib new file mode 100644 index 0000000000000000000000000000000000000000..3d3dd2521804fd13f1d5bee0aaf4456e02dd7202 GIT binary patch literal 11006 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 Jt+!6ezX5(5Y@YxC literal 0 HcmV?d00001 diff --git a/coprocs/NVIDIA/mswin/x64/Release/lib/nvapi.lib b/coprocs/NVIDIA/mswin/x64/Release/lib/nvapi.lib new file mode 100644 index 0000000000000000000000000000000000000000..3d3dd2521804fd13f1d5bee0aaf4456e02dd7202 GIT binary patch literal 11006 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 Jt+!6ezX5(5Y@YxC literal 0 HcmV?d00001 diff --git a/coprocs/OpenCL/include/cl.h b/coprocs/OpenCL/include/cl.h new file mode 100644 index 0000000000..eb099b8ed8 --- /dev/null +++ b/coprocs/OpenCL/include/cl.h @@ -0,0 +1,1001 @@ +/******************************************************************************* + * Copyright (c) 2008-2010 The Khronos Group Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and/or associated documentation files (the + * "Materials"), to deal in the Materials without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Materials, and to + * permit persons to whom the Materials are furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Materials. + * + * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. + ******************************************************************************/ + +/* $Revision: 11985 $ on $Date: 2010-07-15 11:16:06 -0700 (Thu, 15 Jul 2010) $ */ + +#ifndef __OPENCL_CL_H +#define __OPENCL_CL_H + +#if 0 // Modified for BOINC +#ifdef __APPLE__ +#include +#else +#include +#endif +#else +#include "cl_platform.h" +#endif + +#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_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; +typedef cl_bitfield cl_command_queue_properties; + +typedef intptr_t cl_context_properties; +typedef cl_uint cl_context_info; +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; +typedef cl_uint cl_mem_object_type; +typedef cl_uint cl_mem_info; +typedef cl_uint cl_image_info; +typedef cl_uint cl_buffer_create_type; +typedef cl_uint cl_addressing_mode; +typedef cl_uint cl_filter_mode; +typedef cl_uint cl_sampler_info; +typedef cl_bitfield cl_map_flags; +typedef cl_uint cl_program_info; +typedef cl_uint cl_program_build_info; +typedef cl_int cl_build_status; +typedef cl_uint cl_kernel_info; +typedef cl_uint cl_kernel_work_group_info; +typedef cl_uint cl_event_info; +typedef cl_uint cl_command_type; +typedef cl_uint cl_profiling_info; + +typedef struct _cl_image_format { + cl_channel_order image_channel_order; + cl_channel_type image_channel_data_type; +} cl_image_format; + + +typedef struct _cl_buffer_region { + size_t origin; + size_t size; +} cl_buffer_region; + +/******************************************************************************/ + +/* 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 +#define CL_MISALIGNED_SUB_BUFFER_OFFSET -13 +#define CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST -14 + +#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 +#define CL_INVALID_PROPERTY -64 + +/* OpenCL Version */ +#define CL_VERSION_1_0 1 +#define CL_VERSION_1_1 1 + +/* cl_bool */ +#define CL_FALSE 0 +#define CL_TRUE 1 + +/* 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 + +/* 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) +#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 +#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 +#define CL_DEVICE_DOUBLE_FP_CONFIG 0x1032 +#define CL_DEVICE_HALF_FP_CONFIG 0x1033 +#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF 0x1034 +#define CL_DEVICE_HOST_UNIFIED_MEMORY 0x1035 +#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 + +/* 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) +#define CL_FP_SOFT_FLOAT (1 << 6) + +/* 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) + +/* cl_context_info */ +#define CL_CONTEXT_REFERENCE_COUNT 0x1080 +#define CL_CONTEXT_DEVICES 0x1081 +#define CL_CONTEXT_PROPERTIES 0x1082 +#define CL_CONTEXT_NUM_DEVICES 0x1083 + +/* cl_context_info + cl_context_properties */ +#define CL_CONTEXT_PLATFORM 0x1084 + +/* 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 + +/* cl_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) + +/* 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 +#define CL_Rx 0x10BA +#define CL_RGx 0x10BB +#define CL_RGBx 0x10BC + +/* 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 + +/* cl_mem_object_type */ +#define CL_MEM_OBJECT_BUFFER 0x10F0 +#define CL_MEM_OBJECT_IMAGE2D 0x10F1 +#define CL_MEM_OBJECT_IMAGE3D 0x10F2 + +/* 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 +#define CL_MEM_ASSOCIATED_MEMOBJECT 0x1107 +#define CL_MEM_OFFSET 0x1108 + +/* 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 + +/* 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 +#define CL_ADDRESS_MIRRORED_REPEAT 0x1134 + +/* 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 + +/* cl_map_flags - bitfield */ +#define CL_MAP_READ (1 << 0) +#define CL_MAP_WRITE (1 << 1) + +/* 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 + +/* cl_program_build_info */ +#define CL_PROGRAM_BUILD_STATUS 0x1181 +#define CL_PROGRAM_BUILD_OPTIONS 0x1182 +#define CL_PROGRAM_BUILD_LOG 0x1183 + +/* 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 + +/* 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 + +/* 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 +#define CL_EVENT_CONTEXT 0x11D4 + +/* 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 +#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 + +/* command execution status */ +#define CL_COMPLETE 0x0 +#define CL_RUNNING 0x1 +#define CL_SUBMITTED 0x2 +#define CL_QUEUED 0x3 + +/* cl_buffer_create_type */ +#define CL_BUFFER_CREATE_TYPE_REGION 0x1220 + +/* 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 + +/********************************************************************************************************/ + +/* 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; + +/* 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 *, const void *, size_t, void *), + 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 *, const void *, size_t, void *), + 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; + +/* Command Queue APIs */ +extern 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; + +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; + +#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_EXT_SUFFIX__VERSION_1_0_DEPRECATED; +#endif /* CL_USE_DEPRECATED_OPENCL_1_0_APIS */ + +/* 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; + +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; + +extern 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; + +extern 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; + +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; + +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; + +/* Sampler APIs */ +extern 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; + +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; + +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; + +extern CL_API_ENTRY cl_int CL_API_CALL +clUnloadCompiler(void) CL_API_SUFFIX__VERSION_1_0; + +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; + +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; + +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; + +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; + +/* 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; + +extern CL_API_ENTRY cl_event CL_API_CALL +clCreateUserEvent(cl_context /* context */, + cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_1; + +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; + +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, cl_int, void *), + void * /* user_data */) CL_API_SUFFIX__VERSION_1_1; + +/* 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 /* 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; + +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; + +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 /* 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; + +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; + +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 /* cb */, + 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 +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; + +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[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; + +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[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; + +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[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; + +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[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; + +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[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; + +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 /* 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; + +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[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; + +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; + +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 +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; + +extern 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; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueMarker(cl_command_queue /* command_queue */, + cl_event * /* event */) CL_API_SUFFIX__VERSION_1_0; + +extern 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; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueBarrier(cl_command_queue /* command_queue */) CL_API_SUFFIX__VERSION_1_0; + +/* 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 clGetExtensionFunctionAddress(const char * /* func_name */) CL_API_SUFFIX__VERSION_1_0; + +#ifdef __cplusplus +} +#endif + +#endif /* __OPENCL_CL_H */ + diff --git a/coprocs/OpenCL/include/cl_platform.h b/coprocs/OpenCL/include/cl_platform.h new file mode 100644 index 0000000000..4e41d0795c --- /dev/null +++ b/coprocs/OpenCL/include/cl_platform.h @@ -0,0 +1,1114 @@ +/********************************************************************************** + * Copyright (c) 2008-2010 The Khronos Group Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and/or associated documentation files (the + * "Materials"), to deal in the Materials without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Materials, and to + * permit persons to whom the Materials are furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Materials. + * + * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. + **********************************************************************************/ + +/* $Revision: 11803 $ on $Date: 2010-06-25 10:02:12 -0700 (Fri, 25 Jun 2010) $ */ + +#ifndef __CL_PLATFORM_H +#define __CL_PLATFORM_H + +#if 0 //#ifdef __APPLE__ // Modified for BOINC + /* Contains #defines for AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER below */ + #include +#endif + +#if !defined(_WIN32) || !defined(_MSC_VER) +# include +#endif /* !_WIN32 */ +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#if defined(_WIN32) +#define CL_API_ENTRY +#define CL_API_CALL __stdcall + #define CL_CALLBACK __stdcall +#else +#define CL_API_ENTRY +#define CL_API_CALL + #define CL_CALLBACK +#endif + +// BOINC uses OS 10.4, OS 10.5 SDKs for Mac builds, so AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER is undefined +#if 0 //#ifdef __APPLE__ // Modified for BOINC + #define CL_EXTENSION_WEAK_LINK __attribute__((weak_import)) + #define CL_API_SUFFIX__VERSION_1_0 AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER + #define CL_EXT_SUFFIX__VERSION_1_0 CL_EXTENSION_WEAK_LINK AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER + #define CL_API_SUFFIX__VERSION_1_1 CL_EXTENSION_WEAK_LINK + #define CL_EXT_SUFFIX__VERSION_1_1 CL_EXTENSION_WEAK_LINK + #define CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED CL_EXTENSION_WEAK_LINK AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER +#else + #define CL_EXTENSION_WEAK_LINK + #define CL_API_SUFFIX__VERSION_1_0 + #define CL_EXT_SUFFIX__VERSION_1_0 + #define CL_API_SUFFIX__VERSION_1_1 + #define CL_EXT_SUFFIX__VERSION_1_1 + #define CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED +#endif + +#if (defined (_WIN32) && defined(_MSC_VER)) + +/* 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; +#else /* !_WIN32 */ +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; +#endif /* !_WIN32 */ +typedef float cl_float; +typedef double cl_double; + +#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 FLT_MAX +#define CL_FLT_MIN FLT_MIN +#define CL_FLT_EPSILON FLT_EPSILON + +#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 DBL_MAX +#define CL_DBL_MIN DBL_MIN +#define CL_DBL_EPSILON DBL_EPSILON + +#define CL_M_E 2.718281828459045090796 +#define CL_M_LOG2E 1.442695040888963387005 +#define CL_M_LOG10E 0.434294481903251816668 +#define CL_M_LN2 0.693147180559945286227 +#define CL_M_LN10 2.302585092994045901094 +#define CL_M_PI 3.141592653589793115998 +#define CL_M_PI_2 1.570796326794896557999 +#define CL_M_PI_4 0.785398163397448278999 +#define CL_M_1_PI 0.318309886183790691216 +#define CL_M_2_PI 0.636619772367581382433 +#define CL_M_2_SQRTPI 1.128379167095512558561 +#define CL_M_SQRT2 1.414213562373095145475 +#define CL_M_SQRT1_2 0.707106781186547572737 + +#define CL_M_E_F 2.71828174591064f +#define CL_M_LOG2E_F 1.44269502162933f +#define CL_M_LOG10E_F 0.43429449200630f +#define CL_M_LN2_F 0.69314718246460f +#define CL_M_LN10_F 2.30258512496948f +#define CL_M_PI_F 3.14159274101257f +#define CL_M_PI_2_F 1.57079637050629f +#define CL_M_PI_4_F 0.78539818525314f +#define CL_M_1_PI_F 0.31830987334251f +#define CL_M_2_PI_F 0.63661974668503f +#define CL_M_2_SQRTPI_F 1.12837922573090f +#define CL_M_SQRT2_F 1.41421353816986f +#define CL_M_SQRT1_2_F 0.70710676908493f + +#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 + +#include + +/* Mirror types to GL types. Mirror types allow us to avoid deciding which headers 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__ ) + #include /* may be omitted depending on compiler. AltiVec spec provides no way to detect whether the header is required. */ + 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__ ) && !defined( __ICC ) + 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__ ) && !defined( __ICC ) + 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__ ) && !defined( __ICC ) + 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__ ) && !defined( __ICC ) + 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 alignment keys */ +#if defined( __GNUC__ ) + #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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + /* .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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_char x, y; }; + __extension__ struct{ cl_char s0, s1; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_char x, y, z, w; }; + __extension__ struct{ cl_char s0, s1, s2, s3; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_char x, y, z, w; }; + __extension__ struct{ cl_char s0, s1, s2, s3, s4, s5, s6, s7; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_char x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; + __extension__ struct{ cl_char s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_uchar x, y; }; + __extension__ struct{ cl_uchar s0, s1; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_uchar x, y, z, w; }; + __extension__ struct{ cl_uchar s0, s1, s2, s3; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_uchar x, y, z, w; }; + __extension__ struct{ cl_uchar s0, s1, s2, s3, s4, s5, s6, s7; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_uchar x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; + __extension__ struct{ cl_uchar s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_short x, y; }; + __extension__ struct{ cl_short s0, s1; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_short x, y, z, w; }; + __extension__ struct{ cl_short s0, s1, s2, s3; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_short x, y, z, w; }; + __extension__ struct{ cl_short s0, s1, s2, s3, s4, s5, s6, s7; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_short x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; + __extension__ struct{ cl_short s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_ushort x, y; }; + __extension__ struct{ cl_ushort s0, s1; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_ushort x, y, z, w; }; + __extension__ struct{ cl_ushort s0, s1, s2, s3; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_ushort x, y, z, w; }; + __extension__ struct{ cl_ushort s0, s1, s2, s3, s4, s5, s6, s7; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_ushort x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; + __extension__ struct{ cl_ushort s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; + __extension__ 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_intn ---- */ +typedef union +{ + cl_int CL_ALIGNED(8) s[2]; +#if defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_int x, y; }; + __extension__ struct{ cl_int s0, s1; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_int x, y, z, w; }; + __extension__ struct{ cl_int s0, s1, s2, s3; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_int x, y, z, w; }; + __extension__ struct{ cl_int s0, s1, s2, s3, s4, s5, s6, s7; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_int x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; + __extension__ struct{ cl_int s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_uint x, y; }; + __extension__ struct{ cl_uint s0, s1; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_uint x, y, z, w; }; + __extension__ struct{ cl_uint s0, s1, s2, s3; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_uint x, y, z, w; }; + __extension__ struct{ cl_uint s0, s1, s2, s3, s4, s5, s6, s7; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_uint x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; + __extension__ struct{ cl_uint s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_long x, y; }; + __extension__ struct{ cl_long s0, s1; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_long x, y, z, w; }; + __extension__ struct{ cl_long s0, s1, s2, s3; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_long x, y, z, w; }; + __extension__ struct{ cl_long s0, s1, s2, s3, s4, s5, s6, s7; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_long x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; + __extension__ struct{ cl_long s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_ulong x, y; }; + __extension__ struct{ cl_ulong s0, s1; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_ulong x, y, z, w; }; + __extension__ struct{ cl_ulong s0, s1, s2, s3; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_ulong x, y, z, w; }; + __extension__ struct{ cl_ulong s0, s1, s2, s3, s4, s5, s6, s7; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_ulong x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; + __extension__ struct{ cl_ulong s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_float x, y; }; + __extension__ struct{ cl_float s0, s1; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_float x, y, z, w; }; + __extension__ struct{ cl_float s0, s1, s2, s3; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_float x, y, z, w; }; + __extension__ struct{ cl_float s0, s1, s2, s3, s4, s5, s6, s7; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_float x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; + __extension__ struct{ cl_float s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_double x, y; }; + __extension__ struct{ cl_double s0, s1; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_double x, y, z, w; }; + __extension__ struct{ cl_double s0, s1, s2, s3; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_double x, y, z, w; }; + __extension__ struct{ cl_double s0, s1, s2, s3, s4, s5, s6, s7; }; + __extension__ 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 defined( __GNUC__) && ! defined( __STRICT_ANSI__ ) + __extension__ struct{ cl_double x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; }; + __extension__ struct{ cl_double s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; }; + __extension__ 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_BEGIN \" + * Each line thereafter of OpenCL C source must end with: \n\ + * The last line ends in "; + * + * Example: + * + * const char *my_program = CL_PROGRAM_STRING_BEGIN "\ + * 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 + +#endif /* __CL_PLATFORM_H */