mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2025-07-22 22:00:39 -06:00
Dynamically load OpenCL on Windows with CLRun. There shouldn't be the need to make a separate build now or download a big SDK to link Dolphin.
If compilation fails, rebuild the whole solution as Visual Studio struggles with the not so complex project dependencies. ATI users still need to install the Stream SDK as it's the only way to have an OpenCL driver. NVidia users just have to install a recent driver (version 197 is tested and working). git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5808 8ced0084-cf51-0410-be5f-012b33b47a6e
This commit is contained in:
Orphis
355
Externals/CLRun/clrun/CLRun.vcproj
vendored
Normal file
355
Externals/CLRun/clrun/CLRun.vcproj
vendored
Normal file
@ -0,0 +1,355 @@
|
||||
<?xml version="1.0" encoding="windows-1255"?>
|
||||
<VisualStudioProject
|
||||
ProjectType="Visual C++"
|
||||
Version="9,00"
|
||||
Name="CLRun"
|
||||
ProjectGUID="{D4833C30-FA5F-4DFE-BD32-109DE1F09ED1}"
|
||||
RootNamespace="CLRun"
|
||||
TargetFrameworkVersion="196613"
|
||||
>
|
||||
<Platforms>
|
||||
<Platform
|
||||
Name="Win32"
|
||||
/>
|
||||
<Platform
|
||||
Name="x64"
|
||||
/>
|
||||
</Platforms>
|
||||
<ToolFiles>
|
||||
</ToolFiles>
|
||||
<Configurations>
|
||||
<Configuration
|
||||
Name="Debug|Win32"
|
||||
OutputDirectory="$(SolutionDir)\$(ConfigurationName)\$(PlatformName)"
|
||||
IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
|
||||
ConfigurationType="4"
|
||||
CharacterSet="2"
|
||||
>
|
||||
<Tool
|
||||
Name="VCPreBuildEventTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCCustomBuildTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCXMLDataGeneratorTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCWebServiceProxyGeneratorTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCMIDLTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
Optimization="0"
|
||||
AdditionalIncludeDirectories="..\include"
|
||||
PreprocessorDefinitions="CLRUN_COMPILE;WIN32"
|
||||
MinimalRebuild="true"
|
||||
BasicRuntimeChecks="3"
|
||||
RuntimeLibrary="1"
|
||||
WarningLevel="3"
|
||||
DebugInformationFormat="4"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCManagedResourceCompilerTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCResourceCompilerTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCPreLinkEventTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCLibrarianTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCALinkTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCXDCMakeTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCBscMakeTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCFxCopTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCPostBuildEventTool"
|
||||
/>
|
||||
</Configuration>
|
||||
<Configuration
|
||||
Name="Debug|x64"
|
||||
OutputDirectory="$(SolutionDir)\$(ConfigurationName)\$(PlatformName)"
|
||||
IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
|
||||
ConfigurationType="4"
|
||||
CharacterSet="2"
|
||||
>
|
||||
<Tool
|
||||
Name="VCPreBuildEventTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCCustomBuildTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCXMLDataGeneratorTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCWebServiceProxyGeneratorTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCMIDLTool"
|
||||
TargetEnvironment="3"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
Optimization="0"
|
||||
AdditionalIncludeDirectories="..\include"
|
||||
PreprocessorDefinitions="CLRUN_COMPILE;WIN32"
|
||||
MinimalRebuild="true"
|
||||
BasicRuntimeChecks="3"
|
||||
RuntimeLibrary="1"
|
||||
WarningLevel="3"
|
||||
DebugInformationFormat="3"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCManagedResourceCompilerTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCResourceCompilerTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCPreLinkEventTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCLibrarianTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCALinkTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCXDCMakeTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCBscMakeTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCFxCopTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCPostBuildEventTool"
|
||||
/>
|
||||
</Configuration>
|
||||
<Configuration
|
||||
Name="Release|Win32"
|
||||
OutputDirectory="$(SolutionDir)\$(ConfigurationName)\$(PlatformName)"
|
||||
IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
|
||||
ConfigurationType="4"
|
||||
CharacterSet="2"
|
||||
WholeProgramOptimization="1"
|
||||
>
|
||||
<Tool
|
||||
Name="VCPreBuildEventTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCCustomBuildTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCXMLDataGeneratorTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCWebServiceProxyGeneratorTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCMIDLTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
Optimization="2"
|
||||
EnableIntrinsicFunctions="true"
|
||||
AdditionalIncludeDirectories="..\include"
|
||||
PreprocessorDefinitions="CLRUN_COMPILE;WIN32"
|
||||
RuntimeLibrary="0"
|
||||
EnableFunctionLevelLinking="true"
|
||||
WarningLevel="3"
|
||||
DebugInformationFormat="3"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCManagedResourceCompilerTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCResourceCompilerTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCPreLinkEventTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCLibrarianTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCALinkTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCXDCMakeTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCBscMakeTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCFxCopTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCPostBuildEventTool"
|
||||
/>
|
||||
</Configuration>
|
||||
<Configuration
|
||||
Name="Release|x64"
|
||||
OutputDirectory="$(SolutionDir)\$(ConfigurationName)\$(PlatformName)"
|
||||
IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
|
||||
ConfigurationType="4"
|
||||
CharacterSet="2"
|
||||
WholeProgramOptimization="1"
|
||||
>
|
||||
<Tool
|
||||
Name="VCPreBuildEventTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCCustomBuildTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCXMLDataGeneratorTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCWebServiceProxyGeneratorTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCMIDLTool"
|
||||
TargetEnvironment="3"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
Optimization="2"
|
||||
EnableIntrinsicFunctions="true"
|
||||
AdditionalIncludeDirectories="..\include"
|
||||
PreprocessorDefinitions="CLRUN_COMPILE;WIN32"
|
||||
RuntimeLibrary="0"
|
||||
EnableFunctionLevelLinking="true"
|
||||
WarningLevel="3"
|
||||
DebugInformationFormat="3"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCManagedResourceCompilerTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCResourceCompilerTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCPreLinkEventTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCLibrarianTool"
|
||||
IgnoreAllDefaultLibraries="false"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCALinkTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCXDCMakeTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCBscMakeTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCFxCopTool"
|
||||
/>
|
||||
<Tool
|
||||
Name="VCPostBuildEventTool"
|
||||
/>
|
||||
</Configuration>
|
||||
</Configurations>
|
||||
<References>
|
||||
</References>
|
||||
<Files>
|
||||
<Filter
|
||||
Name="Source Files"
|
||||
Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
|
||||
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
|
||||
>
|
||||
<File
|
||||
RelativePath=".\clrun.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\dynamiclib.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\gencl.c"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\genclgl.c"
|
||||
>
|
||||
</File>
|
||||
</Filter>
|
||||
<Filter
|
||||
Name="Header Files"
|
||||
Filter="h;hpp;hxx;hm;inl;inc;xsd"
|
||||
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
|
||||
>
|
||||
<File
|
||||
RelativePath="..\include\clrun.h"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath=".\dynamiclib.h"
|
||||
>
|
||||
</File>
|
||||
<Filter
|
||||
Name="OpenCL"
|
||||
>
|
||||
<File
|
||||
RelativePath="..\include\CL\cl.h"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath="..\include\CL\cl_gl.h"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath="..\include\CL\cl_platform.h"
|
||||
>
|
||||
</File>
|
||||
</Filter>
|
||||
</Filter>
|
||||
<Filter
|
||||
Name="Resource Files"
|
||||
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
|
||||
UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
|
||||
>
|
||||
<File
|
||||
RelativePath=".\generateClRun.pl"
|
||||
>
|
||||
<FileConfiguration
|
||||
Name="Debug|Win32"
|
||||
ExcludedFromBuild="true"
|
||||
>
|
||||
<Tool
|
||||
Name="VCCustomBuildTool"
|
||||
/>
|
||||
</FileConfiguration>
|
||||
<FileConfiguration
|
||||
Name="Debug|x64"
|
||||
ExcludedFromBuild="true"
|
||||
>
|
||||
<Tool
|
||||
Name="VCCustomBuildTool"
|
||||
/>
|
||||
</FileConfiguration>
|
||||
</File>
|
||||
</Filter>
|
||||
</Files>
|
||||
<Globals>
|
||||
</Globals>
|
||||
</VisualStudioProject>
|
||||
16
Externals/CLRun/clrun/Makefile
vendored
Normal file
16
Externals/CLRun/clrun/Makefile
vendored
Normal file
@ -0,0 +1,16 @@
|
||||
all: compile
|
||||
|
||||
compile: genclrun gencl.c genclgl.c
|
||||
gcc -Wall -c gencl.c -o gencl.o
|
||||
gcc -Wall -c genclgl.c -o genclgl.o
|
||||
gcc -Wall -c clrun.c -o clrun.o -I../include
|
||||
gcc -Wall --shared dynamiclib.c clrun.o gencl.o genclgl.o -o libclrun.so -ldl
|
||||
strip libclrun.so
|
||||
|
||||
genclrun: ../include/CL/cl.h ../include/CL/cl_gl.h
|
||||
./generateClRun.pl ../include/CL/cl.h > gencl.c
|
||||
./generateClRun.pl ../include/CL/cl_gl.h > genclgl.c
|
||||
|
||||
|
||||
clean:
|
||||
rm -rf *~ *.o
|
||||
61
Externals/CLRun/clrun/clrun.c
vendored
Normal file
61
Externals/CLRun/clrun/clrun.c
vendored
Normal file
@ -0,0 +1,61 @@
|
||||
#include "clrun.h"
|
||||
#include "dynamiclib.h"
|
||||
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
int isCL = 0;
|
||||
|
||||
// 0 means no opencl, 1 means opencl
|
||||
int clrInit() {
|
||||
int ret = 0;
|
||||
|
||||
#ifdef _WIN32
|
||||
const char *libname = "OpenCL.dll";
|
||||
#else
|
||||
const char *libname = "libOpenCL.so";
|
||||
#endif
|
||||
|
||||
if((ret = loadLib(libname))) {
|
||||
if(ret == -3) // No OpenCL
|
||||
return 0;
|
||||
else
|
||||
return ret;
|
||||
}
|
||||
|
||||
isCL = 1;
|
||||
|
||||
// TODO: optimize by loading all functions here?
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int clrHasOpenCL() {
|
||||
return isCL;
|
||||
}
|
||||
|
||||
|
||||
// Windows-specific DLL code
|
||||
#if defined _WIN32 && defined CLRUN_DYNAMICLIB
|
||||
HINSTANCE g_hInstance;
|
||||
|
||||
BOOL APIENTRY DllMain(HINSTANCE hinstDLL, // DLL module handle
|
||||
DWORD dwReason, // reason called
|
||||
LPVOID lpvReserved) // reserved
|
||||
{
|
||||
switch (dwReason)
|
||||
{
|
||||
case DLL_PROCESS_ATTACH:
|
||||
break;
|
||||
|
||||
case DLL_PROCESS_DETACH:
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
g_hInstance = hinstDLL;
|
||||
return TRUE;
|
||||
}
|
||||
#endif
|
||||
63
Externals/CLRun/clrun/dynamiclib.c
vendored
Normal file
63
Externals/CLRun/clrun/dynamiclib.c
vendored
Normal file
@ -0,0 +1,63 @@
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
HINSTANCE library = NULL;
|
||||
#else
|
||||
#include <dlfcn.h>
|
||||
#include <stdio.h>
|
||||
void *library = NULL;
|
||||
#endif
|
||||
#include <string.h>
|
||||
|
||||
int loadLib(const char *filename) {
|
||||
if (library)
|
||||
return -1;
|
||||
|
||||
if (!filename || strlen(filename) == 0)
|
||||
return -2;
|
||||
|
||||
#ifdef _WIN32
|
||||
library = LoadLibrary(filename);
|
||||
#else
|
||||
library = dlopen(filename, RTLD_NOW | RTLD_LOCAL);
|
||||
#endif
|
||||
|
||||
if (!library)
|
||||
return -3;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int unloadLib()
|
||||
{
|
||||
int retval;
|
||||
if (!library)
|
||||
return -1;
|
||||
|
||||
#ifdef _WIN32
|
||||
retval = FreeLibrary(library);
|
||||
#else
|
||||
retval = dlclose(library);
|
||||
#endif
|
||||
|
||||
library = NULL;
|
||||
return retval;
|
||||
}
|
||||
|
||||
void *getFunction(const char *funcname) {
|
||||
void* retval;
|
||||
|
||||
if (!library) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
#ifdef _WIN32
|
||||
retval = GetProcAddress(library, funcname);
|
||||
#else
|
||||
retval = dlsym(library, funcname);
|
||||
#endif
|
||||
|
||||
if (!retval)
|
||||
return NULL;
|
||||
|
||||
return retval;
|
||||
}
|
||||
9
Externals/CLRun/clrun/dynamiclib.h
vendored
Normal file
9
Externals/CLRun/clrun/dynamiclib.h
vendored
Normal file
@ -0,0 +1,9 @@
|
||||
|
||||
#ifndef __DYNAMIC_LIBRARY_H
|
||||
#define __DYNAMIC_LIBRARY_H
|
||||
|
||||
int loadLib(const char *filename);
|
||||
int unloadLib();
|
||||
void *getFunction(const char *funcname);
|
||||
|
||||
#endif
|
||||
401
Externals/CLRun/clrun/gencl.c
vendored
Normal file
401
Externals/CLRun/clrun/gencl.c
vendored
Normal file
@ -0,0 +1,401 @@
|
||||
// Automatically generated by generateClRun.pl
|
||||
#include "dynamiclib.h"
|
||||
#include "../include/CL/cl.h"
|
||||
|
||||
|
||||
static cl_int (*clGetPlatformIDs_ptr)(cl_uint, cl_platform_id *, cl_uint *) = NULL;
|
||||
cl_int CL_API_CALL clGetPlatformIDs (cl_uint num_entries,cl_platform_id * platforms,cl_uint * num_platforms) {
|
||||
if(!clGetPlatformIDs_ptr) clGetPlatformIDs_ptr = getFunction("clGetPlatformIDs");
|
||||
return (*clGetPlatformIDs_ptr)(num_entries, platforms, num_platforms);
|
||||
}
|
||||
|
||||
static cl_int (*clGetPlatformInfo_ptr)(cl_platform_id, cl_platform_info, size_t, void *, size_t *) = NULL;
|
||||
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) {
|
||||
if(!clGetPlatformInfo_ptr) clGetPlatformInfo_ptr = getFunction("clGetPlatformInfo");
|
||||
return (*clGetPlatformInfo_ptr)(platform, param_name, param_value_size, param_value, param_value_size_ret);
|
||||
}
|
||||
|
||||
static cl_int (*clGetDeviceIDs_ptr)(cl_platform_id, cl_device_type, cl_uint, cl_device_id *, cl_uint *) = NULL;
|
||||
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) {
|
||||
if(!clGetDeviceIDs_ptr) clGetDeviceIDs_ptr = getFunction("clGetDeviceIDs");
|
||||
return (*clGetDeviceIDs_ptr)(platform, device_type, num_entries, devices, num_devices);
|
||||
}
|
||||
|
||||
static cl_int (*clGetDeviceInfo_ptr)(cl_device_id, cl_device_info, size_t, void *, size_t *) = NULL;
|
||||
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) {
|
||||
if(!clGetDeviceInfo_ptr) clGetDeviceInfo_ptr = getFunction("clGetDeviceInfo");
|
||||
return (*clGetDeviceInfo_ptr)(device, param_name, param_value_size, param_value, param_value_size_ret);
|
||||
}
|
||||
|
||||
static cl_context (*clCreateContext_ptr)(const cl_context_properties *, cl_uint, const cl_device_id *, void (CL_CALLBACK *)(const char *, const void *, size_t, void *), void *, cl_int *) = NULL;
|
||||
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) {
|
||||
if(!clCreateContext_ptr) clCreateContext_ptr = getFunction("clCreateContext");
|
||||
return (*clCreateContext_ptr)(properties, num_devices, devices, pfn_notify, user_data, errcode_ret);
|
||||
}
|
||||
|
||||
static cl_context (*clCreateContextFromType_ptr)(const cl_context_properties *, cl_device_type, void (CL_CALLBACK *)(const char *, const void *, size_t, void *), void *, cl_int *) = NULL;
|
||||
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) {
|
||||
if(!clCreateContextFromType_ptr) clCreateContextFromType_ptr = getFunction("clCreateContextFromType");
|
||||
return (*clCreateContextFromType_ptr)(properties, device_type, pfn_notify, user_data, errcode_ret);
|
||||
}
|
||||
|
||||
static cl_int (*clRetainContext_ptr)(cl_context) = NULL;
|
||||
cl_int CL_API_CALL clRetainContext (cl_context context) {
|
||||
if(!clRetainContext_ptr) clRetainContext_ptr = getFunction("clRetainContext");
|
||||
return (*clRetainContext_ptr)(context);
|
||||
}
|
||||
|
||||
static cl_int (*clReleaseContext_ptr)(cl_context) = NULL;
|
||||
cl_int CL_API_CALL clReleaseContext (cl_context context) {
|
||||
if(!clReleaseContext_ptr) clReleaseContext_ptr = getFunction("clReleaseContext");
|
||||
return (*clReleaseContext_ptr)(context);
|
||||
}
|
||||
|
||||
static cl_int (*clGetContextInfo_ptr)(cl_context, cl_context_info, size_t, void *, size_t *) = NULL;
|
||||
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) {
|
||||
if(!clGetContextInfo_ptr) clGetContextInfo_ptr = getFunction("clGetContextInfo");
|
||||
return (*clGetContextInfo_ptr)(context, param_name, param_value_size, param_value, param_value_size_ret);
|
||||
}
|
||||
|
||||
static cl_command_queue (*clCreateCommandQueue_ptr)(cl_context, cl_device_id, cl_command_queue_properties, cl_int *) = NULL;
|
||||
cl_command_queue CL_API_CALL clCreateCommandQueue (cl_context context,cl_device_id device,cl_command_queue_properties properties,cl_int * errcode_ret) {
|
||||
if(!clCreateCommandQueue_ptr) clCreateCommandQueue_ptr = getFunction("clCreateCommandQueue");
|
||||
return (*clCreateCommandQueue_ptr)(context, device, properties, errcode_ret);
|
||||
}
|
||||
|
||||
static cl_int (*clRetainCommandQueue_ptr)(cl_command_queue) = NULL;
|
||||
cl_int CL_API_CALL clRetainCommandQueue (cl_command_queue command_queue) {
|
||||
if(!clRetainCommandQueue_ptr) clRetainCommandQueue_ptr = getFunction("clRetainCommandQueue");
|
||||
return (*clRetainCommandQueue_ptr)(command_queue);
|
||||
}
|
||||
|
||||
static cl_int (*clReleaseCommandQueue_ptr)(cl_command_queue) = NULL;
|
||||
cl_int CL_API_CALL clReleaseCommandQueue (cl_command_queue command_queue) {
|
||||
if(!clReleaseCommandQueue_ptr) clReleaseCommandQueue_ptr = getFunction("clReleaseCommandQueue");
|
||||
return (*clReleaseCommandQueue_ptr)(command_queue);
|
||||
}
|
||||
|
||||
static cl_int (*clGetCommandQueueInfo_ptr)(cl_command_queue, cl_command_queue_info, size_t, void *, size_t *) = NULL;
|
||||
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) {
|
||||
if(!clGetCommandQueueInfo_ptr) clGetCommandQueueInfo_ptr = getFunction("clGetCommandQueueInfo");
|
||||
return (*clGetCommandQueueInfo_ptr)(command_queue, param_name, param_value_size, param_value, param_value_size_ret);
|
||||
}
|
||||
|
||||
static cl_int (*clSetCommandQueueProperty_ptr)(cl_command_queue, cl_command_queue_properties, cl_bool, cl_command_queue_properties *) = NULL;
|
||||
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) {
|
||||
if(!clSetCommandQueueProperty_ptr) clSetCommandQueueProperty_ptr = getFunction("clSetCommandQueueProperty");
|
||||
return (*clSetCommandQueueProperty_ptr)(command_queue, properties, enable, old_properties);
|
||||
}
|
||||
|
||||
static cl_mem (*clCreateBuffer_ptr)(cl_context, cl_mem_flags, size_t, void *, cl_int *) = NULL;
|
||||
cl_mem CL_API_CALL clCreateBuffer (cl_context context,cl_mem_flags flags,size_t size,void * host_ptr,cl_int * errcode_ret) {
|
||||
if(!clCreateBuffer_ptr) clCreateBuffer_ptr = getFunction("clCreateBuffer");
|
||||
return (*clCreateBuffer_ptr)(context, flags, size, host_ptr, errcode_ret);
|
||||
}
|
||||
|
||||
static cl_mem (*clCreateImage2D_ptr)(cl_context, cl_mem_flags, const cl_image_format *, size_t, size_t, size_t, void *, cl_int *) = NULL;
|
||||
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) {
|
||||
if(!clCreateImage2D_ptr) clCreateImage2D_ptr = getFunction("clCreateImage2D");
|
||||
return (*clCreateImage2D_ptr)(context, flags, image_format, image_width, image_height, image_row_pitch, host_ptr, errcode_ret);
|
||||
}
|
||||
|
||||
static cl_mem (*clCreateImage3D_ptr)(cl_context, cl_mem_flags, const cl_image_format *, size_t, size_t, size_t, size_t, size_t, void *, cl_int *) = NULL;
|
||||
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) {
|
||||
if(!clCreateImage3D_ptr) clCreateImage3D_ptr = getFunction("clCreateImage3D");
|
||||
return (*clCreateImage3D_ptr)(context, flags, image_format, image_width, image_height, image_depth, image_row_pitch, image_slice_pitch, host_ptr, errcode_ret);
|
||||
}
|
||||
|
||||
static cl_int (*clRetainMemObject_ptr)(cl_mem) = NULL;
|
||||
cl_int CL_API_CALL clRetainMemObject (cl_mem memobj) {
|
||||
if(!clRetainMemObject_ptr) clRetainMemObject_ptr = getFunction("clRetainMemObject");
|
||||
return (*clRetainMemObject_ptr)(memobj);
|
||||
}
|
||||
|
||||
static cl_int (*clReleaseMemObject_ptr)(cl_mem) = NULL;
|
||||
cl_int CL_API_CALL clReleaseMemObject (cl_mem memobj) {
|
||||
if(!clReleaseMemObject_ptr) clReleaseMemObject_ptr = getFunction("clReleaseMemObject");
|
||||
return (*clReleaseMemObject_ptr)(memobj);
|
||||
}
|
||||
|
||||
static cl_int (*clGetSupportedImageFormats_ptr)(cl_context, cl_mem_flags, cl_mem_object_type, cl_uint, cl_image_format *, cl_uint *) = NULL;
|
||||
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) {
|
||||
if(!clGetSupportedImageFormats_ptr) clGetSupportedImageFormats_ptr = getFunction("clGetSupportedImageFormats");
|
||||
return (*clGetSupportedImageFormats_ptr)(context, flags, image_type, num_entries, image_formats, num_image_formats);
|
||||
}
|
||||
|
||||
static cl_int (*clGetMemObjectInfo_ptr)(cl_mem, cl_mem_info, size_t, void *, size_t *) = NULL;
|
||||
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) {
|
||||
if(!clGetMemObjectInfo_ptr) clGetMemObjectInfo_ptr = getFunction("clGetMemObjectInfo");
|
||||
return (*clGetMemObjectInfo_ptr)(memobj, param_name, param_value_size, param_value, param_value_size_ret);
|
||||
}
|
||||
|
||||
static cl_int (*clGetImageInfo_ptr)(cl_mem, cl_image_info, size_t, void *, size_t *) = NULL;
|
||||
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) {
|
||||
if(!clGetImageInfo_ptr) clGetImageInfo_ptr = getFunction("clGetImageInfo");
|
||||
return (*clGetImageInfo_ptr)(image, param_name, param_value_size, param_value, param_value_size_ret);
|
||||
}
|
||||
|
||||
static cl_sampler (*clCreateSampler_ptr)(cl_context, cl_bool, cl_addressing_mode, cl_filter_mode, cl_int *) = NULL;
|
||||
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) {
|
||||
if(!clCreateSampler_ptr) clCreateSampler_ptr = getFunction("clCreateSampler");
|
||||
return (*clCreateSampler_ptr)(context, normalized_coords, addressing_mode, filter_mode, errcode_ret);
|
||||
}
|
||||
|
||||
static cl_int (*clRetainSampler_ptr)(cl_sampler) = NULL;
|
||||
cl_int CL_API_CALL clRetainSampler (cl_sampler sampler) {
|
||||
if(!clRetainSampler_ptr) clRetainSampler_ptr = getFunction("clRetainSampler");
|
||||
return (*clRetainSampler_ptr)(sampler);
|
||||
}
|
||||
|
||||
static cl_int (*clReleaseSampler_ptr)(cl_sampler) = NULL;
|
||||
cl_int CL_API_CALL clReleaseSampler (cl_sampler sampler) {
|
||||
if(!clReleaseSampler_ptr) clReleaseSampler_ptr = getFunction("clReleaseSampler");
|
||||
return (*clReleaseSampler_ptr)(sampler);
|
||||
}
|
||||
|
||||
static cl_int (*clGetSamplerInfo_ptr)(cl_sampler, cl_sampler_info, size_t, void *, size_t *) = NULL;
|
||||
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) {
|
||||
if(!clGetSamplerInfo_ptr) clGetSamplerInfo_ptr = getFunction("clGetSamplerInfo");
|
||||
return (*clGetSamplerInfo_ptr)(sampler, param_name, param_value_size, param_value, param_value_size_ret);
|
||||
}
|
||||
|
||||
static cl_program (*clCreateProgramWithSource_ptr)(cl_context, cl_uint, const char **, const size_t *, cl_int *) = NULL;
|
||||
cl_program CL_API_CALL clCreateProgramWithSource (cl_context context,cl_uint count,const char ** strings,const size_t * lengths,cl_int * errcode_ret) {
|
||||
if(!clCreateProgramWithSource_ptr) clCreateProgramWithSource_ptr = getFunction("clCreateProgramWithSource");
|
||||
return (*clCreateProgramWithSource_ptr)(context, count, strings, lengths, errcode_ret);
|
||||
}
|
||||
|
||||
static cl_program (*clCreateProgramWithBinary_ptr)(cl_context, cl_uint, const cl_device_id *, const size_t *, const unsigned char **, cl_int *, cl_int *) = NULL;
|
||||
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) {
|
||||
if(!clCreateProgramWithBinary_ptr) clCreateProgramWithBinary_ptr = getFunction("clCreateProgramWithBinary");
|
||||
return (*clCreateProgramWithBinary_ptr)(context, num_devices, device_list, lengths, binaries, binary_status, errcode_ret);
|
||||
}
|
||||
|
||||
static cl_int (*clRetainProgram_ptr)(cl_program) = NULL;
|
||||
cl_int CL_API_CALL clRetainProgram (cl_program program) {
|
||||
if(!clRetainProgram_ptr) clRetainProgram_ptr = getFunction("clRetainProgram");
|
||||
return (*clRetainProgram_ptr)(program);
|
||||
}
|
||||
|
||||
static cl_int (*clReleaseProgram_ptr)(cl_program) = NULL;
|
||||
cl_int CL_API_CALL clReleaseProgram (cl_program program) {
|
||||
if(!clReleaseProgram_ptr) clReleaseProgram_ptr = getFunction("clReleaseProgram");
|
||||
return (*clReleaseProgram_ptr)(program);
|
||||
}
|
||||
|
||||
static cl_int (*clBuildProgram_ptr)(cl_program, cl_uint, const cl_device_id *, const char *, void (CL_CALLBACK * /* pfn_notify */)(cl_program /* program */, void *), void *) = NULL;
|
||||
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 *),void * user_data) {
|
||||
if(!clBuildProgram_ptr) clBuildProgram_ptr = getFunction("clBuildProgram");
|
||||
return (*clBuildProgram_ptr)(program, num_devices, device_list, options, pfn_notify, user_data);
|
||||
}
|
||||
|
||||
static cl_int (*clUnloadCompiler_ptr)(void) = NULL;
|
||||
cl_int CL_API_CALL clUnloadCompiler (void) {
|
||||
if(!clUnloadCompiler_ptr) clUnloadCompiler_ptr = getFunction("clUnloadCompiler");
|
||||
return (*clUnloadCompiler_ptr)();
|
||||
}
|
||||
|
||||
static cl_int (*clGetProgramInfo_ptr)(cl_program, cl_program_info, size_t, void *, size_t *) = NULL;
|
||||
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) {
|
||||
if(!clGetProgramInfo_ptr) clGetProgramInfo_ptr = getFunction("clGetProgramInfo");
|
||||
return (*clGetProgramInfo_ptr)(program, param_name, param_value_size, param_value, param_value_size_ret);
|
||||
}
|
||||
|
||||
static cl_int (*clGetProgramBuildInfo_ptr)(cl_program, cl_device_id, cl_program_build_info, size_t, void *, size_t *) = NULL;
|
||||
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) {
|
||||
if(!clGetProgramBuildInfo_ptr) clGetProgramBuildInfo_ptr = getFunction("clGetProgramBuildInfo");
|
||||
return (*clGetProgramBuildInfo_ptr)(program, device, param_name, param_value_size, param_value, param_value_size_ret);
|
||||
}
|
||||
|
||||
static cl_kernel (*clCreateKernel_ptr)(cl_program, const char *, cl_int *) = NULL;
|
||||
cl_kernel CL_API_CALL clCreateKernel (cl_program program,const char * kernel_name,cl_int * errcode_ret) {
|
||||
if(!clCreateKernel_ptr) clCreateKernel_ptr = getFunction("clCreateKernel");
|
||||
return (*clCreateKernel_ptr)(program, kernel_name, errcode_ret);
|
||||
}
|
||||
|
||||
static cl_int (*clCreateKernelsInProgram_ptr)(cl_program, cl_uint, cl_kernel *, cl_uint *) = NULL;
|
||||
cl_int CL_API_CALL clCreateKernelsInProgram (cl_program program,cl_uint num_kernels,cl_kernel * kernels,cl_uint * num_kernels_ret) {
|
||||
if(!clCreateKernelsInProgram_ptr) clCreateKernelsInProgram_ptr = getFunction("clCreateKernelsInProgram");
|
||||
return (*clCreateKernelsInProgram_ptr)(program, num_kernels, kernels, num_kernels_ret);
|
||||
}
|
||||
|
||||
static cl_int (*clRetainKernel_ptr)(cl_kernel) = NULL;
|
||||
cl_int CL_API_CALL clRetainKernel (cl_kernel kernel) {
|
||||
if(!clRetainKernel_ptr) clRetainKernel_ptr = getFunction("clRetainKernel");
|
||||
return (*clRetainKernel_ptr)(kernel);
|
||||
}
|
||||
|
||||
static cl_int (*clReleaseKernel_ptr)(cl_kernel) = NULL;
|
||||
cl_int CL_API_CALL clReleaseKernel (cl_kernel kernel) {
|
||||
if(!clReleaseKernel_ptr) clReleaseKernel_ptr = getFunction("clReleaseKernel");
|
||||
return (*clReleaseKernel_ptr)(kernel);
|
||||
}
|
||||
|
||||
static cl_int (*clSetKernelArg_ptr)(cl_kernel, cl_uint, size_t, const void *) = NULL;
|
||||
cl_int CL_API_CALL clSetKernelArg (cl_kernel kernel,cl_uint arg_index,size_t arg_size,const void * arg_value) {
|
||||
if(!clSetKernelArg_ptr) clSetKernelArg_ptr = getFunction("clSetKernelArg");
|
||||
return (*clSetKernelArg_ptr)(kernel, arg_index, arg_size, arg_value);
|
||||
}
|
||||
|
||||
static cl_int (*clGetKernelInfo_ptr)(cl_kernel, cl_kernel_info, size_t, void *, size_t *) = NULL;
|
||||
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) {
|
||||
if(!clGetKernelInfo_ptr) clGetKernelInfo_ptr = getFunction("clGetKernelInfo");
|
||||
return (*clGetKernelInfo_ptr)(kernel, param_name, param_value_size, param_value, param_value_size_ret);
|
||||
}
|
||||
|
||||
static cl_int (*clGetKernelWorkGroupInfo_ptr)(cl_kernel, cl_device_id, cl_kernel_work_group_info, size_t, void *, size_t *) = NULL;
|
||||
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) {
|
||||
if(!clGetKernelWorkGroupInfo_ptr) clGetKernelWorkGroupInfo_ptr = getFunction("clGetKernelWorkGroupInfo");
|
||||
return (*clGetKernelWorkGroupInfo_ptr)(kernel, device, param_name, param_value_size, param_value, param_value_size_ret);
|
||||
}
|
||||
|
||||
static cl_int (*clWaitForEvents_ptr)(cl_uint, const cl_event *) = NULL;
|
||||
cl_int CL_API_CALL clWaitForEvents (cl_uint num_events,const cl_event * event_list) {
|
||||
if(!clWaitForEvents_ptr) clWaitForEvents_ptr = getFunction("clWaitForEvents");
|
||||
return (*clWaitForEvents_ptr)(num_events, event_list);
|
||||
}
|
||||
|
||||
static cl_int (*clGetEventInfo_ptr)(cl_event, cl_event_info, size_t, void *, size_t *) = NULL;
|
||||
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) {
|
||||
if(!clGetEventInfo_ptr) clGetEventInfo_ptr = getFunction("clGetEventInfo");
|
||||
return (*clGetEventInfo_ptr)(event, param_name, param_value_size, param_value, param_value_size_ret);
|
||||
}
|
||||
|
||||
static cl_int (*clRetainEvent_ptr)(cl_event) = NULL;
|
||||
cl_int CL_API_CALL clRetainEvent (cl_event event) {
|
||||
if(!clRetainEvent_ptr) clRetainEvent_ptr = getFunction("clRetainEvent");
|
||||
return (*clRetainEvent_ptr)(event);
|
||||
}
|
||||
|
||||
static cl_int (*clReleaseEvent_ptr)(cl_event) = NULL;
|
||||
cl_int CL_API_CALL clReleaseEvent (cl_event event) {
|
||||
if(!clReleaseEvent_ptr) clReleaseEvent_ptr = getFunction("clReleaseEvent");
|
||||
return (*clReleaseEvent_ptr)(event);
|
||||
}
|
||||
|
||||
static cl_int (*clGetEventProfilingInfo_ptr)(cl_event, cl_profiling_info, size_t, void *, size_t *) = NULL;
|
||||
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) {
|
||||
if(!clGetEventProfilingInfo_ptr) clGetEventProfilingInfo_ptr = getFunction("clGetEventProfilingInfo");
|
||||
return (*clGetEventProfilingInfo_ptr)(event, param_name, param_value_size, param_value, param_value_size_ret);
|
||||
}
|
||||
|
||||
static cl_int (*clFlush_ptr)(cl_command_queue) = NULL;
|
||||
cl_int CL_API_CALL clFlush (cl_command_queue command_queue) {
|
||||
if(!clFlush_ptr) clFlush_ptr = getFunction("clFlush");
|
||||
return (*clFlush_ptr)(command_queue);
|
||||
}
|
||||
|
||||
static cl_int (*clFinish_ptr)(cl_command_queue) = NULL;
|
||||
cl_int CL_API_CALL clFinish (cl_command_queue command_queue) {
|
||||
if(!clFinish_ptr) clFinish_ptr = getFunction("clFinish");
|
||||
return (*clFinish_ptr)(command_queue);
|
||||
}
|
||||
|
||||
static cl_int (*clEnqueueReadBuffer_ptr)(cl_command_queue, cl_mem, cl_bool, size_t, size_t, void *, cl_uint, const cl_event *, cl_event *) = NULL;
|
||||
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) {
|
||||
if(!clEnqueueReadBuffer_ptr) clEnqueueReadBuffer_ptr = getFunction("clEnqueueReadBuffer");
|
||||
return (*clEnqueueReadBuffer_ptr)(command_queue, buffer, blocking_read, offset, cb, ptr, num_events_in_wait_list, event_wait_list, event);
|
||||
}
|
||||
|
||||
static cl_int (*clEnqueueWriteBuffer_ptr)(cl_command_queue, cl_mem, cl_bool, size_t, size_t, const void *, cl_uint, const cl_event *, cl_event *) = NULL;
|
||||
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) {
|
||||
if(!clEnqueueWriteBuffer_ptr) clEnqueueWriteBuffer_ptr = getFunction("clEnqueueWriteBuffer");
|
||||
return (*clEnqueueWriteBuffer_ptr)(command_queue, buffer, blocking_write, offset, cb, ptr, num_events_in_wait_list, event_wait_list, event);
|
||||
}
|
||||
|
||||
static cl_int (*clEnqueueCopyBuffer_ptr)(cl_command_queue, cl_mem, cl_mem, size_t, size_t, size_t, cl_uint, const cl_event *, cl_event *) = NULL;
|
||||
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) {
|
||||
if(!clEnqueueCopyBuffer_ptr) clEnqueueCopyBuffer_ptr = getFunction("clEnqueueCopyBuffer");
|
||||
return (*clEnqueueCopyBuffer_ptr)(command_queue, src_buffer, dst_buffer, src_offset, dst_offset, cb, num_events_in_wait_list, event_wait_list, event);
|
||||
}
|
||||
|
||||
static cl_int (*clEnqueueReadImage_ptr)(cl_command_queue, cl_mem, cl_bool, const size_t *, const size_t *, size_t, size_t, void *, cl_uint, const cl_event *, cl_event *) = NULL;
|
||||
cl_int CL_API_CALL clEnqueueReadImage (cl_command_queue command_queue,cl_mem image,cl_bool blocking_read,const size_t * origin,const size_t * region,size_t row_pitch,size_t slice_pitch,void * ptr,cl_uint num_events_in_wait_list,const cl_event * event_wait_list,cl_event * event) {
|
||||
if(!clEnqueueReadImage_ptr) clEnqueueReadImage_ptr = getFunction("clEnqueueReadImage");
|
||||
return (*clEnqueueReadImage_ptr)(command_queue, image, blocking_read, origin, region, row_pitch, slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event);
|
||||
}
|
||||
|
||||
static cl_int (*clEnqueueWriteImage_ptr)(cl_command_queue, cl_mem, cl_bool, const size_t *, const size_t *, size_t, size_t, const void *, cl_uint, const cl_event *, cl_event *) = NULL;
|
||||
cl_int CL_API_CALL clEnqueueWriteImage (cl_command_queue command_queue,cl_mem image,cl_bool blocking_write,const size_t * origin,const size_t * region,size_t input_row_pitch,size_t input_slice_pitch,const void * ptr,cl_uint num_events_in_wait_list,const cl_event * event_wait_list,cl_event * event) {
|
||||
if(!clEnqueueWriteImage_ptr) clEnqueueWriteImage_ptr = getFunction("clEnqueueWriteImage");
|
||||
return (*clEnqueueWriteImage_ptr)(command_queue, image, blocking_write, origin, region, input_row_pitch, input_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event);
|
||||
}
|
||||
|
||||
static cl_int (*clEnqueueCopyImage_ptr)(cl_command_queue, cl_mem, cl_mem, const size_t *, const size_t *, const size_t *, cl_uint, const cl_event *, cl_event *) = NULL;
|
||||
cl_int CL_API_CALL clEnqueueCopyImage (cl_command_queue command_queue,cl_mem src_image,cl_mem dst_image,const size_t * src_origin,const size_t * dst_origin,const size_t * region,cl_uint num_events_in_wait_list,const cl_event * event_wait_list,cl_event * event) {
|
||||
if(!clEnqueueCopyImage_ptr) clEnqueueCopyImage_ptr = getFunction("clEnqueueCopyImage");
|
||||
return (*clEnqueueCopyImage_ptr)(command_queue, src_image, dst_image, src_origin, dst_origin, region, num_events_in_wait_list, event_wait_list, event);
|
||||
}
|
||||
|
||||
static cl_int (*clEnqueueCopyImageToBuffer_ptr)(cl_command_queue, cl_mem, cl_mem, const size_t *, const size_t *, size_t, cl_uint, const cl_event *, cl_event *) = NULL;
|
||||
cl_int CL_API_CALL clEnqueueCopyImageToBuffer (cl_command_queue command_queue,cl_mem src_image,cl_mem dst_buffer,const size_t * src_origin,const size_t * region,size_t dst_offset,cl_uint num_events_in_wait_list,const cl_event * event_wait_list,cl_event * event) {
|
||||
if(!clEnqueueCopyImageToBuffer_ptr) clEnqueueCopyImageToBuffer_ptr = getFunction("clEnqueueCopyImageToBuffer");
|
||||
return (*clEnqueueCopyImageToBuffer_ptr)(command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_events_in_wait_list, event_wait_list, event);
|
||||
}
|
||||
|
||||
static cl_int (*clEnqueueCopyBufferToImage_ptr)(cl_command_queue, cl_mem, cl_mem, size_t, const size_t *, const size_t *, cl_uint, const cl_event *, cl_event *) = NULL;
|
||||
cl_int CL_API_CALL clEnqueueCopyBufferToImage (cl_command_queue command_queue,cl_mem src_buffer,cl_mem dst_image,size_t src_offset,const size_t * dst_origin,const size_t * region,cl_uint num_events_in_wait_list,const cl_event * event_wait_list,cl_event * event) {
|
||||
if(!clEnqueueCopyBufferToImage_ptr) clEnqueueCopyBufferToImage_ptr = getFunction("clEnqueueCopyBufferToImage");
|
||||
return (*clEnqueueCopyBufferToImage_ptr)(command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_events_in_wait_list, event_wait_list, event);
|
||||
}
|
||||
|
||||
static void * (*clEnqueueMapBuffer_ptr)(cl_command_queue, cl_mem, cl_bool, cl_map_flags, size_t, size_t, cl_uint, const cl_event *, cl_event *, cl_int *) = NULL;
|
||||
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) {
|
||||
if(!clEnqueueMapBuffer_ptr) clEnqueueMapBuffer_ptr = getFunction("clEnqueueMapBuffer");
|
||||
return (*clEnqueueMapBuffer_ptr)(command_queue, buffer, blocking_map, map_flags, offset, cb, num_events_in_wait_list, event_wait_list, event, errcode_ret);
|
||||
}
|
||||
|
||||
static void * (*clEnqueueMapImage_ptr)(cl_command_queue, cl_mem, cl_bool, cl_map_flags, const size_t *, const size_t *, size_t *, size_t *, cl_uint, const cl_event *, cl_event *, cl_int *) = NULL;
|
||||
void * CL_API_CALL clEnqueueMapImage (cl_command_queue command_queue,cl_mem image,cl_bool blocking_map,cl_map_flags map_flags,const size_t * origin,const size_t * region,size_t * image_row_pitch,size_t * image_slice_pitch,cl_uint num_events_in_wait_list,const cl_event * event_wait_list,cl_event * event,cl_int * errcode_ret) {
|
||||
if(!clEnqueueMapImage_ptr) clEnqueueMapImage_ptr = getFunction("clEnqueueMapImage");
|
||||
return (*clEnqueueMapImage_ptr)(command_queue, image, blocking_map, map_flags, origin, region, image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list, event, errcode_ret);
|
||||
}
|
||||
|
||||
static cl_int (*clEnqueueUnmapMemObject_ptr)(cl_command_queue, cl_mem, void *, cl_uint, const cl_event *, cl_event *) = NULL;
|
||||
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) {
|
||||
if(!clEnqueueUnmapMemObject_ptr) clEnqueueUnmapMemObject_ptr = getFunction("clEnqueueUnmapMemObject");
|
||||
return (*clEnqueueUnmapMemObject_ptr)(command_queue, memobj, mapped_ptr, num_events_in_wait_list, event_wait_list, event);
|
||||
}
|
||||
|
||||
static cl_int (*clEnqueueNDRangeKernel_ptr)(cl_command_queue, cl_kernel, cl_uint, const size_t *, const size_t *, const size_t *, cl_uint, const cl_event *, cl_event *) = NULL;
|
||||
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) {
|
||||
if(!clEnqueueNDRangeKernel_ptr) clEnqueueNDRangeKernel_ptr = getFunction("clEnqueueNDRangeKernel");
|
||||
return (*clEnqueueNDRangeKernel_ptr)(command_queue, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_events_in_wait_list, event_wait_list, event);
|
||||
}
|
||||
|
||||
static cl_int (*clEnqueueTask_ptr)(cl_command_queue, cl_kernel, cl_uint, const cl_event *, cl_event *) = NULL;
|
||||
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) {
|
||||
if(!clEnqueueTask_ptr) clEnqueueTask_ptr = getFunction("clEnqueueTask");
|
||||
return (*clEnqueueTask_ptr)(command_queue, kernel, num_events_in_wait_list, event_wait_list, event);
|
||||
}
|
||||
|
||||
static cl_int (*clEnqueueNativeKernel_ptr)(cl_command_queue, void (*)(void *), void *, size_t, cl_uint, const cl_mem *, const void **, cl_uint, const cl_event *, cl_event *) = NULL;
|
||||
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) {
|
||||
if(!clEnqueueNativeKernel_ptr) clEnqueueNativeKernel_ptr = getFunction("clEnqueueNativeKernel");
|
||||
return (*clEnqueueNativeKernel_ptr)(command_queue, user_func, args, cb_args, num_mem_objects, mem_list, args_mem_loc, num_events_in_wait_list, event_wait_list, event);
|
||||
}
|
||||
|
||||
static cl_int (*clEnqueueMarker_ptr)(cl_command_queue, cl_event *) = NULL;
|
||||
cl_int CL_API_CALL clEnqueueMarker (cl_command_queue command_queue,cl_event * event) {
|
||||
if(!clEnqueueMarker_ptr) clEnqueueMarker_ptr = getFunction("clEnqueueMarker");
|
||||
return (*clEnqueueMarker_ptr)(command_queue, event);
|
||||
}
|
||||
|
||||
static cl_int (*clEnqueueWaitForEvents_ptr)(cl_command_queue, cl_uint, const cl_event *) = NULL;
|
||||
cl_int CL_API_CALL clEnqueueWaitForEvents (cl_command_queue command_queue,cl_uint num_events,const cl_event * event_list) {
|
||||
if(!clEnqueueWaitForEvents_ptr) clEnqueueWaitForEvents_ptr = getFunction("clEnqueueWaitForEvents");
|
||||
return (*clEnqueueWaitForEvents_ptr)(command_queue, num_events, event_list);
|
||||
}
|
||||
|
||||
static cl_int (*clEnqueueBarrier_ptr)(cl_command_queue) = NULL;
|
||||
cl_int CL_API_CALL clEnqueueBarrier (cl_command_queue command_queue) {
|
||||
if(!clEnqueueBarrier_ptr) clEnqueueBarrier_ptr = getFunction("clEnqueueBarrier");
|
||||
return (*clEnqueueBarrier_ptr)(command_queue);
|
||||
}
|
||||
|
||||
static void * (*clGetExtensionFunctionAddress_ptr)(const char *) = NULL;
|
||||
void * CL_API_CALL clGetExtensionFunctionAddress (const char * func_name) {
|
||||
if(!clGetExtensionFunctionAddress_ptr) clGetExtensionFunctionAddress_ptr = getFunction("clGetExtensionFunctionAddress");
|
||||
return (*clGetExtensionFunctionAddress_ptr)(func_name);
|
||||
}
|
||||
|
||||
58
Externals/CLRun/clrun/genclgl.c
vendored
Normal file
58
Externals/CLRun/clrun/genclgl.c
vendored
Normal file
@ -0,0 +1,58 @@
|
||||
// Automatically generated by generateClRun.pl
|
||||
#include "dynamiclib.h"
|
||||
#include "../include/CL/cl_gl.h"
|
||||
|
||||
|
||||
static cl_mem (*clCreateFromGLBuffer_ptr)(cl_context , cl_mem_flags , cl_GLuint , int * ) = NULL;
|
||||
cl_mem CL_API_CALL clCreateFromGLBuffer (cl_context context,cl_mem_flags flags,cl_GLuint bufobj,int * errcode_ret) {
|
||||
if(!clCreateFromGLBuffer_ptr) clCreateFromGLBuffer_ptr = getFunction("clCreateFromGLBuffer");
|
||||
return (*clCreateFromGLBuffer_ptr)(context , flags , bufobj , errcode_ret );
|
||||
}
|
||||
|
||||
static cl_mem (*clCreateFromGLTexture2D_ptr)(cl_context , cl_mem_flags , cl_GLenum , cl_GLint , cl_GLuint , cl_int * ) = NULL;
|
||||
cl_mem CL_API_CALL clCreateFromGLTexture2D (cl_context context,cl_mem_flags flags,cl_GLenum target,cl_GLint miplevel,cl_GLuint texture,cl_int * errcode_ret) {
|
||||
if(!clCreateFromGLTexture2D_ptr) clCreateFromGLTexture2D_ptr = getFunction("clCreateFromGLTexture2D");
|
||||
return (*clCreateFromGLTexture2D_ptr)(context , flags , target , miplevel , texture , errcode_ret );
|
||||
}
|
||||
|
||||
static cl_mem (*clCreateFromGLTexture3D_ptr)(cl_context , cl_mem_flags , cl_GLenum , cl_GLint , cl_GLuint , cl_int * ) = NULL;
|
||||
cl_mem CL_API_CALL clCreateFromGLTexture3D (cl_context context,cl_mem_flags flags,cl_GLenum target,cl_GLint miplevel,cl_GLuint texture,cl_int * errcode_ret) {
|
||||
if(!clCreateFromGLTexture3D_ptr) clCreateFromGLTexture3D_ptr = getFunction("clCreateFromGLTexture3D");
|
||||
return (*clCreateFromGLTexture3D_ptr)(context , flags , target , miplevel , texture , errcode_ret );
|
||||
}
|
||||
|
||||
static cl_mem (*clCreateFromGLRenderbuffer_ptr)(cl_context , cl_mem_flags , cl_GLuint , cl_int * ) = NULL;
|
||||
cl_mem CL_API_CALL clCreateFromGLRenderbuffer (cl_context context,cl_mem_flags flags,cl_GLuint renderbuffer,cl_int * errcode_ret) {
|
||||
if(!clCreateFromGLRenderbuffer_ptr) clCreateFromGLRenderbuffer_ptr = getFunction("clCreateFromGLRenderbuffer");
|
||||
return (*clCreateFromGLRenderbuffer_ptr)(context , flags , renderbuffer , errcode_ret );
|
||||
}
|
||||
|
||||
static cl_int (*clGetGLObjectInfo_ptr)(cl_mem , cl_gl_object_type * , cl_GLuint * ) = NULL;
|
||||
cl_int CL_API_CALL clGetGLObjectInfo (cl_mem memobj,cl_gl_object_type * gl_object_type,cl_GLuint * gl_object_name) {
|
||||
if(!clGetGLObjectInfo_ptr) clGetGLObjectInfo_ptr = getFunction("clGetGLObjectInfo");
|
||||
return (*clGetGLObjectInfo_ptr)(memobj , gl_object_type , gl_object_name );
|
||||
}
|
||||
|
||||
static cl_int (*clGetGLTextureInfo_ptr)(cl_mem , cl_gl_texture_info , size_t , void * , size_t * ) = NULL;
|
||||
cl_int CL_API_CALL clGetGLTextureInfo (cl_mem memobj,cl_gl_texture_info param_name,size_t param_value_size,void * param_value,size_t * param_value_size_ret) {
|
||||
if(!clGetGLTextureInfo_ptr) clGetGLTextureInfo_ptr = getFunction("clGetGLTextureInfo");
|
||||
return (*clGetGLTextureInfo_ptr)(memobj , param_name , param_value_size , param_value , param_value_size_ret );
|
||||
}
|
||||
|
||||
static cl_int (*clEnqueueAcquireGLObjects_ptr)(cl_command_queue , cl_uint , const cl_mem * , cl_uint , const cl_event * , cl_event * ) = NULL;
|
||||
cl_int CL_API_CALL clEnqueueAcquireGLObjects (cl_command_queue command_queue,cl_uint num_objects,const cl_mem * mem_objects,cl_uint num_events_in_wait_list,const cl_event * event_wait_list,cl_event * event) {
|
||||
if(!clEnqueueAcquireGLObjects_ptr) clEnqueueAcquireGLObjects_ptr = getFunction("clEnqueueAcquireGLObjects");
|
||||
return (*clEnqueueAcquireGLObjects_ptr)(command_queue , num_objects , mem_objects , num_events_in_wait_list , event_wait_list , event );
|
||||
}
|
||||
|
||||
static cl_int (*clEnqueueReleaseGLObjects_ptr)(cl_command_queue , cl_uint , const cl_mem * , cl_uint , const cl_event * , cl_event * ) = NULL;
|
||||
cl_int CL_API_CALL clEnqueueReleaseGLObjects (cl_command_queue command_queue,cl_uint num_objects,const cl_mem * mem_objects,cl_uint num_events_in_wait_list,const cl_event * event_wait_list,cl_event * event) {
|
||||
if(!clEnqueueReleaseGLObjects_ptr) clEnqueueReleaseGLObjects_ptr = getFunction("clEnqueueReleaseGLObjects");
|
||||
return (*clEnqueueReleaseGLObjects_ptr)(command_queue , num_objects , mem_objects , num_events_in_wait_list , event_wait_list , event );
|
||||
}
|
||||
|
||||
static cl_int (*clGetGLContextInfoKHR_ptr)(const cl_context_properties * , cl_gl_context_info , size_t , void * , size_t * ) = NULL;
|
||||
cl_int CL_API_CALL clGetGLContextInfoKHR (const cl_context_properties * properties,cl_gl_context_info param_name,size_t param_value_size,void * param_value,size_t * param_value_size_ret) {
|
||||
if(!clGetGLContextInfoKHR_ptr) clGetGLContextInfoKHR_ptr = getFunction("clGetGLContextInfoKHR");
|
||||
return (*clGetGLContextInfoKHR_ptr)(properties , param_name , param_value_size , param_value , param_value_size_ret );
|
||||
}
|
||||
96
Externals/CLRun/clrun/generateClRun.pl
vendored
Normal file
96
Externals/CLRun/clrun/generateClRun.pl
vendored
Normal file
@ -0,0 +1,96 @@
|
||||
#!/usr/bin/perl -w
|
||||
use strict;
|
||||
|
||||
sub trim($)
|
||||
{
|
||||
my $string = shift;
|
||||
$string =~ s/^\s+//;
|
||||
$string =~ s/\s+$//;
|
||||
return $string;
|
||||
}
|
||||
|
||||
my $filename = shift;
|
||||
|
||||
open(CL, "<$filename") or die "Can't open cl.h";
|
||||
|
||||
my ($funcRet, $funcName, $args);
|
||||
|
||||
print "// Automatically generated by generateClRun.pl\n";
|
||||
print "#include \"dynamiclib.h\"\n";
|
||||
print "#include \"$filename\"\n\n\n";
|
||||
|
||||
while(<CL>) {
|
||||
chomp;
|
||||
next unless $_ =~ /CL_API_ENTRY\s*(.*)\s*CL_API_CALL/;
|
||||
$funcRet = $1;
|
||||
my $fa = "";
|
||||
my $noArgs = 0;
|
||||
while(<CL>) {
|
||||
$fa .= $_;
|
||||
last if $_ =~ /;$/;
|
||||
}
|
||||
|
||||
chomp $fa;
|
||||
$fa =~ s/\s*\).*;\s*$/\)/g; # remove api
|
||||
$fa =~ /([^(]*)\((.*)\)/s;
|
||||
$funcName = $1;
|
||||
$args = $2;
|
||||
|
||||
# split params by , (ignoring function pointers)
|
||||
(my @args) = $args =~ m/([^(,]*(?:\([^)]+\)[^(),]*)*[^),]*),?/g;
|
||||
|
||||
my (@argsTypes, @argsNames);
|
||||
|
||||
my $funcArgSig = "";
|
||||
my $tmp;
|
||||
foreach my $arg (@args) {
|
||||
|
||||
next if ($arg eq "");
|
||||
my ($type, $name) = $arg =~ m|\s*(.*)\s*/\*\s*(.*)\s*\*/|s;
|
||||
|
||||
# Strip []
|
||||
if(defined $name) {
|
||||
$name =~ s/\[.*\]//g;
|
||||
}
|
||||
|
||||
if ($arg =~ /\(.*\)/) {
|
||||
$tmp = $type;
|
||||
$type =~ s/\(\*.*?\)/\(\*\)/g
|
||||
}
|
||||
|
||||
push @argsTypes, trim($type);
|
||||
push @argsNames, trim($name);
|
||||
|
||||
if ($arg =~ /\(.*\)/) {
|
||||
$funcArgSig .= "$tmp,";
|
||||
} elsif(defined $type) {
|
||||
$funcArgSig .= trim($type)." ".trim($name).",";
|
||||
} else { # Functions with no arguments (i.e. "void" only)
|
||||
$funcArgSig = "void,";
|
||||
$noArgs = 1;
|
||||
last;
|
||||
}
|
||||
}
|
||||
|
||||
chop($funcArgSig); #last ,
|
||||
|
||||
my ($funcArgsNames, $funcArgsTypes);
|
||||
|
||||
if($noArgs eq 0) {
|
||||
$funcArgsNames = ($#argsNames != -1)? join ', ',@argsNames : "";
|
||||
$funcArgsTypes = ($#argsTypes != -1)? join ', ',@argsTypes : "";
|
||||
} else {
|
||||
$funcArgsNames = "";
|
||||
$funcArgsTypes = "void";
|
||||
}
|
||||
|
||||
my $func = "${funcName}_ptr";
|
||||
$args =~ s$(/\*|\*/)$$g; # uncomment names
|
||||
print "static ".trim($funcRet)." (*$func)($funcArgsTypes) = NULL;\n";
|
||||
print trim($funcRet)." CL_API_CALL $funcName ($funcArgSig) {\n";
|
||||
print "\tif(!$func) $func = getFunction(\"$funcName\");\n";
|
||||
print "\treturn (*$func)($funcArgsNames);\n";
|
||||
print "}\n\n";
|
||||
}
|
||||
|
||||
close(CL);
|
||||
Reference in New Issue
Block a user