Skip to content

A
angle
Commit 65586746 by John Plate Committed by Commit Bot
Options

add cl entry points loader

Bug: angleproject:5743 Change-Id: I61791f412e8dbc54878cd3791519ad1c4ee33399 Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2749595Reviewed-by: 's avatarCody Northrop <cnorthrop@google.com> Reviewed-by: 's avatarJamie Madill <jmadill@chromium.org> Commit-Queue: John Plate <jplate@google.com>
parent 522d609b
Showing with 1070 additions and 68 deletions
scripts/code_generation_hashes/GL_EGL_WGL_loader.json
{
"scripts/cl.xml":
"c7b7bf8184d73c991f3a1ca11e882894",
"scripts/egl.xml":
"013c552e6c523abdcf268268ea47e9fe",
"scripts/egl_angle_ext.xml":
"5bcc01462b355d933cf3ada15198fb68",
"scripts/generate_loader.py":
"82f0334c0ffe6c271ce0b04af7ec713b",
"3125733515c3cee68c3ee07c7b688da2",
"scripts/gl.xml":
"2a73a58a7e26d8676a2c0af6d528cae6",
"scripts/gl_angle_ext.xml":
......@@ -17,6 +19,8 @@
"3740eb7bd4928f17c4239ab294930469",
"src/libEGL/egl_loader_autogen.h":
"9cbf4d491497058a32642865eb032276",
"src/libOpenCL/cl_loader_autogen.cpp":
"7cf7c0dbc49dab7af837881ef66686be",
"src/tests/restricted_traces/trace_egl_loader_autogen.cpp":
"ab1ce9e72e1e248b13302349f2228a89",
"src/tests/restricted_traces/trace_egl_loader_autogen.h":
......
scripts/code_generation_hashes/GL_EGL_entry_points.json
......@@ -10,7 +10,7 @@
"scripts/entry_point_packed_gl_enums.json":
"4f7b43863a5e61991bba4010db463679",
"scripts/generate_entry_points.py":
"776b9fad21f479a16e23beeed97c53f8",
"a5727169ccae71f737d689a67f59e4c8",
"scripts/gl.xml":
"2a73a58a7e26d8676a2c0af6d528cae6",
"scripts/gl_angle_ext.xml":
......@@ -168,5 +168,7 @@
"src/libOpenCL/entry_points_cl_autogen.cpp":
"9da7a72f6afcd5af04777103612a3bee",
"src/libOpenCL/entry_points_cl_autogen.h":
"3b4a3094e8fd9082b71915b5bd1e8fee"
"3b4a3094e8fd9082b71915b5bd1e8fee",
"src/libOpenCL/libOpenCL_autogen.cpp":
"6a44d6aedb6d21282de91bc719e7f0bf"
}
\ No newline at end of file
scripts/generate_entry_points.py
......@@ -326,6 +326,14 @@ CONTEXT_HEADER = """\
CONTEXT_DECL_FORMAT = """ {return_type} {name_lower_no_suffix}({internal_params}){maybe_const}; \\"""
TEMPLATE_CL_ENTRY_POINT_EXPORT = """\
ANGLE_EXPORT {return_type}CL_API_ENTRY cl{name}({params}) CL_API_CALL
{{
EnsureCLLoaded();
return cl_loader.cl{name}({internal_params});
}}
"""
TEMPLATE_GL_ENTRY_POINT_EXPORT = """\
{return_type}GL_APIENTRY gl{name}{explicit_context_suffix}({explicit_context_param}{explicit_context_comma}{params})
{{
......@@ -799,6 +807,55 @@ EGL_EXT_SOURCE_INCLUDES = """\
using namespace egl;
"""
LIBCL_EXPORT_INCLUDES_AND_PREAMBLE = """
//#include "anglebase/no_destructor.h"
//#include "common/system_utils.h"
#include <iostream>
//#include <memory>
#include "cl_loader.h"
namespace
{
bool gLoaded = false;
/* TODO(jplate): uncomment after entry points moved to GLESV2 lib http://anglebug.com/5759
std::unique_ptr<angle::Library> &EntryPointsLib()
{
static angle::base::NoDestructor<std::unique_ptr<angle::Library>> sEntryPointsLib;
return *sEntryPointsLib;
}
angle::GenericProc CL_API_ENTRY GlobalLoad(const char *symbol)
{
return reinterpret_cast<angle::GenericProc>(EntryPointsLib()->getSymbol(symbol));
}
*/
void EnsureCLLoaded()
{
if (gLoaded)
{
return;
}
// EntryPointsLib().reset(
// angle::OpenSharedLibrary(ANGLE_GLESV2_LIBRARY_NAME, angle::SearchType::ApplicationDir));
// angle::LoadCL(GlobalLoad);
angle::LoadCL(nullptr);
if (!cl_loader.clGetDeviceIDs)
{
std::cerr << "Error loading CL entry points." << std::endl;
}
else
{
gLoaded = true;
}
}
} // anonymous namespace
"""
LIBGLESV2_EXPORT_INCLUDES = """
#include "angle_gl.h"
......@@ -1703,8 +1760,13 @@ class CLEntryPoints(ANGLEEntryPoints):
all_param_types = set()
def __init__(self, xml, commands):
super().__init__(apis.CL, xml, commands, CLEntryPoints.all_param_types,
CLEntryPoints.get_packed_enums())
super().__init__(
apis.CL,
xml,
commands,
CLEntryPoints.all_param_types,
CLEntryPoints.get_packed_enums(),
export_template=TEMPLATE_CL_ENTRY_POINT_EXPORT)
@classmethod
def get_packed_enums(cls):
......@@ -2345,6 +2407,7 @@ def main():
outputs = [
EGL_STUBS_HEADER_PATH,
EGL_EXT_STUBS_HEADER_PATH,
'../src/libOpenCL/libOpenCL_autogen.cpp',
'../src/libOpenCL/entry_points_cl_autogen.cpp',
'../src/libOpenCL/entry_points_cl_autogen.h',
'../src/common/entry_points_enum_autogen.cpp',
......@@ -2689,6 +2752,49 @@ def main():
# Validation files
write_gl_validation_header("GL%s" % major_version, name, validation_protos, "gl.xml")
# OpenCL
clxml = registry_xml.RegistryXML('cl.xml')
cl_validation_protos = []
cl_decls = []
cl_defs = []
libcl_ep_defs = []
libcl_windows_def_exports = []
cl_commands = []
for major_version, minor_version in registry_xml.CL_VERSIONS:
version = "%d_%d" % (major_version, minor_version)
annotation = "CL_%s" % version
name_prefix = "CL_VERSION_"
comment = version.replace("_", ".")
feature_name = "%s%s" % (name_prefix, version)
clxml.AddCommands(feature_name, version)
cl_version_commands = clxml.commands[version]
cl_commands += cl_version_commands
# Spec revs may have no new commands.
if not cl_version_commands:
continue
eps = CLEntryPoints(clxml, cl_version_commands)
comment = "\n// CL %d.%d" % (major_version, minor_version)
win_def_comment = "\n ; CL %d.%d" % (major_version, minor_version)
cl_decls += [comment] + eps.decls
cl_defs += [comment] + eps.defs
libcl_ep_defs += [comment] + eps.export_defs
cl_validation_protos += [comment] + eps.validation_protos
libcl_windows_def_exports += [win_def_comment] + get_exports(clxml.commands[version])
write_file("cl", "CL", TEMPLATE_ENTRY_POINT_HEADER, "\n".join(cl_decls), "h",
LIBCL_HEADER_INCLUDES, "libOpenCL", "cl.xml")
write_file("cl", "CL", TEMPLATE_ENTRY_POINT_SOURCE, "\n".join(cl_defs), "cpp",
LIBCL_SOURCE_INCLUDES, "libOpenCL", "cl.xml")
# EGL
eglxml = registry_xml.RegistryXML('egl.xml', 'egl_angle_ext.xml')
......@@ -2853,6 +2959,8 @@ def main():
write_export_files("\n".join([item for item in libegl_ep_defs]),
LIBEGL_EXPORT_INCLUDES_AND_PREAMBLE, "egl.xml and egl_angle_ext.xml",
"libEGL", "EGL")
write_export_files("\n".join([item for item in libcl_ep_defs]),
LIBCL_EXPORT_INCLUDES_AND_PREAMBLE, "cl.xml", "libOpenCL", "CL")
libgles_ep_exports += get_egl_exports()
......@@ -2870,49 +2978,6 @@ def main():
write_capture_replay_source(apis.GLES, xml.all_commands, all_commands_no_suffix,
GLEntryPoints.get_packed_enums(), [])
# OpenCL
clxml = registry_xml.RegistryXML('cl.xml')
cl_validation_protos = []
cl_decls = []
cl_defs = []
libcl_ep_defs = []
libcl_windows_def_exports = []
cl_commands = []
for major_version, minor_version in registry_xml.CL_VERSIONS:
version = "%d_%d" % (major_version, minor_version)
annotation = "CL_%s" % version
name_prefix = "CL_VERSION_"
comment = version.replace("_", ".")
feature_name = "%s%s" % (name_prefix, version)
clxml.AddCommands(feature_name, version)
cl_version_commands = clxml.commands[version]
cl_commands += cl_version_commands
# Spec revs may have no new commands.
if not cl_version_commands:
continue
eps = CLEntryPoints(clxml, cl_version_commands)
comment = "\n// CL %d.%d" % (major_version, minor_version)
win_def_comment = "\n ; CL %d.%d" % (major_version, minor_version)
cl_decls += [comment] + eps.decls
cl_defs += [comment] + eps.defs
libcl_ep_defs += [comment] + eps.export_defs
cl_validation_protos += [comment] + eps.validation_protos
libcl_windows_def_exports += [win_def_comment] + get_exports(clxml.commands[version])
write_file("cl", "CL", TEMPLATE_ENTRY_POINT_HEADER, "\n".join(cl_decls), "h",
LIBCL_HEADER_INCLUDES, "libOpenCL", "cl.xml")
write_file("cl", "CL", TEMPLATE_ENTRY_POINT_SOURCE, "\n".join(cl_defs), "cpp",
LIBCL_SOURCE_INCLUDES, "libOpenCL", "cl.xml")
if __name__ == '__main__':
sys.exit(main())
scripts/generate_loader.py
......@@ -102,6 +102,35 @@ def write_source(data_source_name,
out.close()
def gen_libcl_loader():
xml = registry_xml.RegistryXML("cl.xml")
for major_version, minor_version in registry_xml.CL_VERSIONS:
name_prefix = "CL_VERSION_"
annotation = "%d_%d" % (major_version, minor_version)
feature_name = "%s%s" % (name_prefix, annotation)
xml.AddCommands(feature_name, annotation)
all_cmds = xml.all_cmd_names.get_all_commands()
path = os.path.join("..", "src", "libOpenCL")
source_path = registry_xml.path_to(path, "cl_loader_autogen.cpp")
with open(source_path, "w") as out:
# TODO(jplate): use first setters after migration in http://anglebug.com/5759
# setter = " cl_loader.%s = reinterpret_cast<cl_api_%s>(loadProc(\"CL_%s\"));"
# setters = [setter % (cmd, cmd, cmd[2:]) for cmd in all_cmds]
setter = " cl_loader.%s = CL_%s;"
setters = [setter % (cmd, cmd[2:]) for cmd in all_cmds]
loader_source = template_cl_loader_cpp.format(
script_name=os.path.basename(sys.argv[0]),
data_source_name="cl.xml",
set_pointers="\n".join(setters))
out.write(loader_source)
out.close()
def gen_libegl_loader():
data_source_name = "egl.xml and egl_angle_ext.xml"
......@@ -266,15 +295,9 @@ def main():
# Handle inputs/outputs for run_code_generation.py's auto_script
if len(sys.argv) > 1:
inputs = [
'gl.xml',
'gl_angle_ext.xml',
'egl.xml',
'egl_angle_ext.xml',
'registry_xml.py',
'wgl.xml',
]
inputs = registry_xml.xml_inputs
outputs = [
'../src/libOpenCL/cl_loader_autogen.cpp',
'../src/libEGL/egl_loader_autogen.cpp',
'../src/libEGL/egl_loader_autogen.h',
'../util/egl_loader_autogen.cpp',
......@@ -298,6 +321,7 @@ def main():
return 1
return 0
gen_libcl_loader()
gen_libegl_loader()
gen_util_gles_and_egl_loaders()
gen_util_wgl_loader()
......@@ -397,5 +421,31 @@ void {load_fn_name}(LoadProc loadProc)
}} // namespace angle
"""
template_cl_loader_cpp = """// GENERATED FILE - DO NOT EDIT.
// Generated by {script_name} using data from {data_source_name}.
//
// Copyright 2021 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// cl_loader_autogen.cpp:
// Simple CL function loader.
#include "cl_loader.h"
// TODO(jplate): remove include after entry points moved to GLESV2 lib http://anglebug.com/5759
#include "entry_points_cl_autogen.h"
cl_icd_dispatch cl_loader;
namespace angle
{{
void LoadCL(LoadProc loadProc)
{{
{set_pointers}
}}
}} // namespace angle
"""
if __name__ == '__main__':
sys.exit(main())
src/libOpenCL/BUILD.gn
......@@ -29,19 +29,28 @@ angle_source_set("cl_includes") {
]
}
angle_shared_library("OpenCL") {
defines = [
"CL_TARGET_OPENCL_VERSION=100",
"LIBCL_IMPLEMENTATION",
]
sources = [
"entry_points_cl_autogen.cpp",
"entry_points_cl_autogen.h",
"entry_points_cl_utils.h",
]
deps = [ ":cl_includes" ]
# TODO(jplate): Fix OpenCL headers for Windows http://anglebug.com/5761
if (is_linux) {
angle_shared_library("OpenCL") {
defines = [
"CL_TARGET_OPENCL_VERSION=100",
"LIBCL_IMPLEMENTATION",
]
sources = [
"cl_loader.h",
"cl_loader_autogen.cpp",
"entry_points_cl_autogen.cpp",
"entry_points_cl_autogen.h",
"entry_points_cl_utils.h",
"libOpenCL_autogen.cpp",
]
deps = [ ":cl_includes" ]
}
}
group("angle_cl") {
data_deps = [ ":OpenCL" ]
# TODO(jplate): Fix OpenCL headers for Windows http://anglebug.com/5761
if (is_linux) {
data_deps = [ ":OpenCL" ]
}
}
src/libOpenCL/cl_loader.h 0 → 100644
//
// Copyright 2021 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// cl_loader.h:
// Simple CL function loader.
#ifndef LIBCL_CL_LOADER_H_
#define LIBCL_CL_LOADER_H_
#include <export.h>
#include <CL/cl_icd.h>
ANGLE_NO_EXPORT extern cl_icd_dispatch cl_loader;
namespace angle
{
using GenericProc = void (*)();
using LoadProc = GenericProc(CL_API_ENTRY *)(const char *);
ANGLE_NO_EXPORT void LoadCL(LoadProc loadProc);
} // namespace angle
#endif // LIBCL_CL_LOADER_H_
src/libOpenCL/cl_loader_autogen.cpp 0 → 100644
// GENERATED FILE - DO NOT EDIT.
// Generated by generate_loader.py using data from cl.xml.
//
// Copyright 2021 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// cl_loader_autogen.cpp:
// Simple CL function loader.
#include "cl_loader.h"
// TODO(jplate): remove include after entry points moved to GLESV2 lib http://anglebug.com/5759
#include "entry_points_cl_autogen.h"
cl_icd_dispatch cl_loader;
namespace angle
{
void LoadCL(LoadProc loadProc)
{
cl_loader.clGetPlatformIDs = CL_GetPlatformIDs;
cl_loader.clGetPlatformInfo = CL_GetPlatformInfo;
cl_loader.clGetDeviceIDs = CL_GetDeviceIDs;
cl_loader.clGetDeviceInfo = CL_GetDeviceInfo;
cl_loader.clCreateContext = CL_CreateContext;
cl_loader.clCreateContextFromType = CL_CreateContextFromType;
cl_loader.clRetainContext = CL_RetainContext;
cl_loader.clReleaseContext = CL_ReleaseContext;
cl_loader.clGetContextInfo = CL_GetContextInfo;
cl_loader.clRetainCommandQueue = CL_RetainCommandQueue;
cl_loader.clReleaseCommandQueue = CL_ReleaseCommandQueue;
cl_loader.clGetCommandQueueInfo = CL_GetCommandQueueInfo;
cl_loader.clCreateBuffer = CL_CreateBuffer;
cl_loader.clRetainMemObject = CL_RetainMemObject;
cl_loader.clReleaseMemObject = CL_ReleaseMemObject;
cl_loader.clGetSupportedImageFormats = CL_GetSupportedImageFormats;
cl_loader.clGetMemObjectInfo = CL_GetMemObjectInfo;
cl_loader.clGetImageInfo = CL_GetImageInfo;
cl_loader.clRetainSampler = CL_RetainSampler;
cl_loader.clReleaseSampler = CL_ReleaseSampler;
cl_loader.clGetSamplerInfo = CL_GetSamplerInfo;
cl_loader.clCreateProgramWithSource = CL_CreateProgramWithSource;
cl_loader.clCreateProgramWithBinary = CL_CreateProgramWithBinary;
cl_loader.clRetainProgram = CL_RetainProgram;
cl_loader.clReleaseProgram = CL_ReleaseProgram;
cl_loader.clBuildProgram = CL_BuildProgram;
cl_loader.clGetProgramInfo = CL_GetProgramInfo;
cl_loader.clGetProgramBuildInfo = CL_GetProgramBuildInfo;
cl_loader.clCreateKernel = CL_CreateKernel;
cl_loader.clCreateKernelsInProgram = CL_CreateKernelsInProgram;
cl_loader.clRetainKernel = CL_RetainKernel;
cl_loader.clReleaseKernel = CL_ReleaseKernel;
cl_loader.clSetKernelArg = CL_SetKernelArg;
cl_loader.clGetKernelInfo = CL_GetKernelInfo;
cl_loader.clGetKernelWorkGroupInfo = CL_GetKernelWorkGroupInfo;
cl_loader.clWaitForEvents = CL_WaitForEvents;
cl_loader.clGetEventInfo = CL_GetEventInfo;
cl_loader.clRetainEvent = CL_RetainEvent;
cl_loader.clReleaseEvent = CL_ReleaseEvent;
cl_loader.clGetEventProfilingInfo = CL_GetEventProfilingInfo;
cl_loader.clFlush = CL_Flush;
cl_loader.clFinish = CL_Finish;
cl_loader.clEnqueueReadBuffer = CL_EnqueueReadBuffer;
cl_loader.clEnqueueWriteBuffer = CL_EnqueueWriteBuffer;
cl_loader.clEnqueueCopyBuffer = CL_EnqueueCopyBuffer;
cl_loader.clEnqueueReadImage = CL_EnqueueReadImage;
cl_loader.clEnqueueWriteImage = CL_EnqueueWriteImage;
cl_loader.clEnqueueCopyImage = CL_EnqueueCopyImage;
cl_loader.clEnqueueCopyImageToBuffer = CL_EnqueueCopyImageToBuffer;
cl_loader.clEnqueueCopyBufferToImage = CL_EnqueueCopyBufferToImage;
cl_loader.clEnqueueMapBuffer = CL_EnqueueMapBuffer;
cl_loader.clEnqueueMapImage = CL_EnqueueMapImage;
cl_loader.clEnqueueUnmapMemObject = CL_EnqueueUnmapMemObject;
cl_loader.clEnqueueNDRangeKernel = CL_EnqueueNDRangeKernel;
cl_loader.clEnqueueNativeKernel = CL_EnqueueNativeKernel;
cl_loader.clSetCommandQueueProperty = CL_SetCommandQueueProperty;
cl_loader.clCreateImage2D = CL_CreateImage2D;
cl_loader.clCreateImage3D = CL_CreateImage3D;
cl_loader.clEnqueueMarker = CL_EnqueueMarker;
cl_loader.clEnqueueWaitForEvents = CL_EnqueueWaitForEvents;
cl_loader.clEnqueueBarrier = CL_EnqueueBarrier;
cl_loader.clUnloadCompiler = CL_UnloadCompiler;
cl_loader.clGetExtensionFunctionAddress = CL_GetExtensionFunctionAddress;
cl_loader.clCreateCommandQueue = CL_CreateCommandQueue;
cl_loader.clCreateSampler = CL_CreateSampler;
cl_loader.clEnqueueTask = CL_EnqueueTask;
}
} // namespace angle
src/libOpenCL/libOpenCL_autogen.cpp 0 → 100644
// GENERATED FILE - DO NOT EDIT.
// Generated by generate_entry_points.py using data from cl.xml.
//
// Copyright 2020 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// libOpenCL_autogen.cpp: Implements the exported CL functions.
//#include "anglebase/no_destructor.h"
//#include "common/system_utils.h"
#include <iostream>
//#include <memory>
#include "cl_loader.h"
namespace
{
bool gLoaded = false;
/* TODO(jplate): uncomment after entry points moved to GLESV2 lib http://anglebug.com/5759
std::unique_ptr<angle::Library> &EntryPointsLib()
{
static angle::base::NoDestructor<std::unique_ptr<angle::Library>> sEntryPointsLib;
return *sEntryPointsLib;
}
angle::GenericProc CL_API_ENTRY GlobalLoad(const char *symbol)
{
return reinterpret_cast<angle::GenericProc>(EntryPointsLib()->getSymbol(symbol));
}
*/
void EnsureCLLoaded()
{
if (gLoaded)
{
return;
}
// EntryPointsLib().reset(
// angle::OpenSharedLibrary(ANGLE_GLESV2_LIBRARY_NAME, angle::SearchType::ApplicationDir));
// angle::LoadCL(GlobalLoad);
angle::LoadCL(nullptr);
if (!cl_loader.clGetDeviceIDs)
{
std::cerr << "Error loading CL entry points." << std::endl;
}
else
{
gLoaded = true;
}
}
} // anonymous namespace
extern "C" {
// CL 1.0
ANGLE_EXPORT cl_int CL_API_ENTRY clGetPlatformIDs(cl_uint num_entries,
cl_platform_id *platforms,
cl_uint *num_platforms) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clGetPlatformIDs(num_entries, platforms, num_platforms);
}
ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
EnsureCLLoaded();
return cl_loader.clGetPlatformInfo(platform, param_name, param_value_size, param_value,
param_value_size_ret);
}
ANGLE_EXPORT cl_int CL_API_ENTRY clGetDeviceIDs(cl_platform_id platform,
cl_device_type device_type,
cl_uint num_entries,
cl_device_id *devices,
cl_uint *num_devices) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clGetDeviceIDs(platform, device_type, num_entries, devices, num_devices);
}
ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
EnsureCLLoaded();
return cl_loader.clGetDeviceInfo(device, param_name, param_value_size, param_value,
param_value_size_ret);
}
ANGLE_EXPORT cl_context CL_API_ENTRY
clCreateContext(const cl_context_properties *properties,
cl_uint num_devices,
const cl_device_id *devices,
void(CL_CALLBACK *pfn_notify)(const char *errinfo,
const void *private_info,
size_t cb,
void *user_data),
void *user_data,
cl_int *errcode_ret) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clCreateContext(properties, num_devices, devices, pfn_notify, user_data,
errcode_ret);
}
ANGLE_EXPORT cl_context CL_API_ENTRY
clCreateContextFromType(const cl_context_properties *properties,
cl_device_type device_type,
void(CL_CALLBACK *pfn_notify)(const char *errinfo,
const void *private_info,
size_t cb,
void *user_data),
void *user_data,
cl_int *errcode_ret) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clCreateContextFromType(properties, device_type, pfn_notify, user_data,
errcode_ret);
}
ANGLE_EXPORT cl_int CL_API_ENTRY clRetainContext(cl_context context) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clRetainContext(context);
}
ANGLE_EXPORT cl_int CL_API_ENTRY clReleaseContext(cl_context context) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clReleaseContext(context);
}
ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
EnsureCLLoaded();
return cl_loader.clGetContextInfo(context, param_name, param_value_size, param_value,
param_value_size_ret);
}
ANGLE_EXPORT cl_int CL_API_ENTRY clRetainCommandQueue(cl_command_queue command_queue) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clRetainCommandQueue(command_queue);
}
ANGLE_EXPORT cl_int CL_API_ENTRY clReleaseCommandQueue(cl_command_queue command_queue) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clReleaseCommandQueue(command_queue);
}
ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
EnsureCLLoaded();
return cl_loader.clGetCommandQueueInfo(command_queue, param_name, param_value_size, param_value,
param_value_size_ret);
}
ANGLE_EXPORT cl_mem CL_API_ENTRY clCreateBuffer(cl_context context,
cl_mem_flags flags,
size_t size,
void *host_ptr,
cl_int *errcode_ret) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clCreateBuffer(context, flags, size, host_ptr, errcode_ret);
}
ANGLE_EXPORT cl_int CL_API_ENTRY clRetainMemObject(cl_mem memobj) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clRetainMemObject(memobj);
}
ANGLE_EXPORT cl_int CL_API_ENTRY clReleaseMemObject(cl_mem memobj) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clReleaseMemObject(memobj);
}
ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
EnsureCLLoaded();
return cl_loader.clGetSupportedImageFormats(context, flags, image_type, num_entries,
image_formats, num_image_formats);
}
ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
EnsureCLLoaded();
return cl_loader.clGetMemObjectInfo(memobj, param_name, param_value_size, param_value,
param_value_size_ret);
}
ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
EnsureCLLoaded();
return cl_loader.clGetImageInfo(image, param_name, param_value_size, param_value,
param_value_size_ret);
}
ANGLE_EXPORT cl_int CL_API_ENTRY clRetainSampler(cl_sampler sampler) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clRetainSampler(sampler);
}
ANGLE_EXPORT cl_int CL_API_ENTRY clReleaseSampler(cl_sampler sampler) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clReleaseSampler(sampler);
}
ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
EnsureCLLoaded();
return cl_loader.clGetSamplerInfo(sampler, param_name, param_value_size, param_value,
param_value_size_ret);
}
ANGLE_EXPORT cl_program CL_API_ENTRY clCreateProgramWithSource(cl_context context,
cl_uint count,
const char **strings,
const size_t *lengths,
cl_int *errcode_ret) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clCreateProgramWithSource(context, count, strings, lengths, errcode_ret);
}
ANGLE_EXPORT cl_program CL_API_ENTRY 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_CALL
{
EnsureCLLoaded();
return cl_loader.clCreateProgramWithBinary(context, num_devices, device_list, lengths, binaries,
binary_status, errcode_ret);
}
ANGLE_EXPORT cl_int CL_API_ENTRY clRetainProgram(cl_program program) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clRetainProgram(program);
}
ANGLE_EXPORT cl_int CL_API_ENTRY clReleaseProgram(cl_program program) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clReleaseProgram(program);
}
ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
EnsureCLLoaded();
return cl_loader.clBuildProgram(program, num_devices, device_list, options, pfn_notify,
user_data);
}
ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
EnsureCLLoaded();
return cl_loader.clGetProgramInfo(program, param_name, param_value_size, param_value,
param_value_size_ret);
}
ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
EnsureCLLoaded();
return cl_loader.clGetProgramBuildInfo(program, device, param_name, param_value_size,
param_value, param_value_size_ret);
}
ANGLE_EXPORT cl_kernel CL_API_ENTRY clCreateKernel(cl_program program,
const char *kernel_name,
cl_int *errcode_ret) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clCreateKernel(program, kernel_name, errcode_ret);
}
ANGLE_EXPORT cl_int CL_API_ENTRY clCreateKernelsInProgram(cl_program program,
cl_uint num_kernels,
cl_kernel *kernels,
cl_uint *num_kernels_ret) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clCreateKernelsInProgram(program, num_kernels, kernels, num_kernels_ret);
}
ANGLE_EXPORT cl_int CL_API_ENTRY clRetainKernel(cl_kernel kernel) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clRetainKernel(kernel);
}
ANGLE_EXPORT cl_int CL_API_ENTRY clReleaseKernel(cl_kernel kernel) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clReleaseKernel(kernel);
}
ANGLE_EXPORT cl_int CL_API_ENTRY clSetKernelArg(cl_kernel kernel,
cl_uint arg_index,
size_t arg_size,
const void *arg_value) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clSetKernelArg(kernel, arg_index, arg_size, arg_value);
}
ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
EnsureCLLoaded();
return cl_loader.clGetKernelInfo(kernel, param_name, param_value_size, param_value,
param_value_size_ret);
}
ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
EnsureCLLoaded();
return cl_loader.clGetKernelWorkGroupInfo(kernel, device, param_name, param_value_size,
param_value, param_value_size_ret);
}
ANGLE_EXPORT cl_int CL_API_ENTRY clWaitForEvents(cl_uint num_events,
const cl_event *event_list) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clWaitForEvents(num_events, event_list);
}
ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
EnsureCLLoaded();
return cl_loader.clGetEventInfo(event, param_name, param_value_size, param_value,
param_value_size_ret);
}
ANGLE_EXPORT cl_int CL_API_ENTRY clRetainEvent(cl_event event) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clRetainEvent(event);
}
ANGLE_EXPORT cl_int CL_API_ENTRY clReleaseEvent(cl_event event) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clReleaseEvent(event);
}
ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
EnsureCLLoaded();
return cl_loader.clGetEventProfilingInfo(event, param_name, param_value_size, param_value,
param_value_size_ret);
}
ANGLE_EXPORT cl_int CL_API_ENTRY clFlush(cl_command_queue command_queue) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clFlush(command_queue);
}
ANGLE_EXPORT cl_int CL_API_ENTRY clFinish(cl_command_queue command_queue) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clFinish(command_queue);
}
ANGLE_EXPORT cl_int CL_API_ENTRY clEnqueueReadBuffer(cl_command_queue command_queue,
cl_mem buffer,
cl_bool blocking_read,
size_t offset,
size_t size,
void *ptr,
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clEnqueueReadBuffer(command_queue, buffer, blocking_read, offset, size, ptr,
num_events_in_wait_list, event_wait_list, event);
}
ANGLE_EXPORT cl_int CL_API_ENTRY clEnqueueWriteBuffer(cl_command_queue command_queue,
cl_mem buffer,
cl_bool blocking_write,
size_t offset,
size_t size,
const void *ptr,
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clEnqueueWriteBuffer(command_queue, buffer, blocking_write, offset, size, ptr,
num_events_in_wait_list, event_wait_list, event);
}
ANGLE_EXPORT cl_int CL_API_ENTRY clEnqueueCopyBuffer(cl_command_queue command_queue,
cl_mem src_buffer,
cl_mem dst_buffer,
size_t src_offset,
size_t dst_offset,
size_t size,
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clEnqueueCopyBuffer(command_queue, src_buffer, dst_buffer, src_offset,
dst_offset, size, num_events_in_wait_list, event_wait_list,
event);
}
ANGLE_EXPORT cl_int CL_API_ENTRY clEnqueueReadImage(cl_command_queue command_queue,
cl_mem image,
cl_bool blocking_read,
const size_t *origin,
const size_t *region,
size_t row_pitch,
size_t slice_pitch,
void *ptr,
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clEnqueueReadImage(command_queue, image, blocking_read, origin, region,
row_pitch, slice_pitch, ptr, num_events_in_wait_list,
event_wait_list, event);
}
ANGLE_EXPORT cl_int CL_API_ENTRY clEnqueueWriteImage(cl_command_queue command_queue,
cl_mem image,
cl_bool blocking_write,
const size_t *origin,
const size_t *region,
size_t input_row_pitch,
size_t input_slice_pitch,
const void *ptr,
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clEnqueueWriteImage(command_queue, image, blocking_write, origin, region,
input_row_pitch, input_slice_pitch, ptr,
num_events_in_wait_list, event_wait_list, event);
}
ANGLE_EXPORT cl_int CL_API_ENTRY clEnqueueCopyImage(cl_command_queue command_queue,
cl_mem src_image,
cl_mem dst_image,
const size_t *src_origin,
const size_t *dst_origin,
const size_t *region,
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clEnqueueCopyImage(command_queue, src_image, dst_image, src_origin, dst_origin,
region, num_events_in_wait_list, event_wait_list, event);
}
ANGLE_EXPORT cl_int CL_API_ENTRY clEnqueueCopyImageToBuffer(cl_command_queue command_queue,
cl_mem src_image,
cl_mem dst_buffer,
const size_t *src_origin,
const size_t *region,
size_t dst_offset,
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clEnqueueCopyImageToBuffer(command_queue, src_image, dst_buffer, src_origin,
region, dst_offset, num_events_in_wait_list,
event_wait_list, event);
}
ANGLE_EXPORT cl_int CL_API_ENTRY clEnqueueCopyBufferToImage(cl_command_queue command_queue,
cl_mem src_buffer,
cl_mem dst_image,
size_t src_offset,
const size_t *dst_origin,
const size_t *region,
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clEnqueueCopyBufferToImage(command_queue, src_buffer, dst_image, src_offset,
dst_origin, region, num_events_in_wait_list,
event_wait_list, event);
}
ANGLE_EXPORT void *CL_API_ENTRY clEnqueueMapBuffer(cl_command_queue command_queue,
cl_mem buffer,
cl_bool blocking_map,
cl_map_flags map_flags,
size_t offset,
size_t size,
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event,
cl_int *errcode_ret) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clEnqueueMapBuffer(command_queue, buffer, blocking_map, map_flags, offset,
size, num_events_in_wait_list, event_wait_list, event,
errcode_ret);
}
ANGLE_EXPORT void *CL_API_ENTRY clEnqueueMapImage(cl_command_queue command_queue,
cl_mem image,
cl_bool blocking_map,
cl_map_flags map_flags,
const size_t *origin,
const size_t *region,
size_t *image_row_pitch,
size_t *image_slice_pitch,
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event,
cl_int *errcode_ret) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clEnqueueMapImage(
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);
}
ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
EnsureCLLoaded();
return cl_loader.clEnqueueUnmapMemObject(command_queue, memobj, mapped_ptr,
num_events_in_wait_list, event_wait_list, event);
}
ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
EnsureCLLoaded();
return cl_loader.clEnqueueNDRangeKernel(command_queue, kernel, work_dim, global_work_offset,
global_work_size, local_work_size,
num_events_in_wait_list, event_wait_list, event);
}
ANGLE_EXPORT cl_int CL_API_ENTRY clEnqueueNativeKernel(cl_command_queue command_queue,
void(CL_CALLBACK *user_func)(void *),
void *args,
size_t cb_args,
cl_uint num_mem_objects,
const cl_mem *mem_list,
const void **args_mem_loc,
cl_uint num_events_in_wait_list,
const cl_event *event_wait_list,
cl_event *event) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clEnqueueNativeKernel(command_queue, user_func, args, cb_args, num_mem_objects,
mem_list, args_mem_loc, num_events_in_wait_list,
event_wait_list, event);
}
ANGLE_EXPORT cl_int CL_API_ENTRY
clSetCommandQueueProperty(cl_command_queue command_queue,
cl_command_queue_properties properties,
cl_bool enable,
cl_command_queue_properties *old_properties) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clSetCommandQueueProperty(command_queue, properties, enable, old_properties);
}
ANGLE_EXPORT cl_mem CL_API_ENTRY 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_CALL
{
EnsureCLLoaded();
return cl_loader.clCreateImage2D(context, flags, image_format, image_width, image_height,
image_row_pitch, host_ptr, errcode_ret);
}
ANGLE_EXPORT cl_mem CL_API_ENTRY 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_CALL
{
EnsureCLLoaded();
return cl_loader.clCreateImage3D(context, flags, image_format, image_width, image_height,
image_depth, image_row_pitch, image_slice_pitch, host_ptr,
errcode_ret);
}
ANGLE_EXPORT cl_int CL_API_ENTRY clEnqueueMarker(cl_command_queue command_queue,
cl_event *event) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clEnqueueMarker(command_queue, event);
}
ANGLE_EXPORT cl_int CL_API_ENTRY clEnqueueWaitForEvents(cl_command_queue command_queue,
cl_uint num_events,
const cl_event *event_list) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clEnqueueWaitForEvents(command_queue, num_events, event_list);
}
ANGLE_EXPORT cl_int CL_API_ENTRY clEnqueueBarrier(cl_command_queue command_queue) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clEnqueueBarrier(command_queue);
}
ANGLE_EXPORT cl_int CL_API_ENTRY clUnloadCompiler() CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clUnloadCompiler();
}
ANGLE_EXPORT void *CL_API_ENTRY clGetExtensionFunctionAddress(const char *func_name) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clGetExtensionFunctionAddress(func_name);
}
ANGLE_EXPORT cl_command_queue CL_API_ENTRY
clCreateCommandQueue(cl_context context,
cl_device_id device,
cl_command_queue_properties properties,
cl_int *errcode_ret) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clCreateCommandQueue(context, device, properties, errcode_ret);
}
ANGLE_EXPORT cl_sampler CL_API_ENTRY clCreateSampler(cl_context context,
cl_bool normalized_coords,
cl_addressing_mode addressing_mode,
cl_filter_mode filter_mode,
cl_int *errcode_ret) CL_API_CALL
{
EnsureCLLoaded();
return cl_loader.clCreateSampler(context, normalized_coords, addressing_mode, filter_mode,
errcode_ret);
}
ANGLE_EXPORT cl_int CL_API_ENTRY 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_CALL
{
EnsureCLLoaded();
return cl_loader.clEnqueueTask(command_queue, kernel, num_events_in_wait_list, event_wait_list,
event);
}
} // extern "C"
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment