Create a module/class with wrapper methods for the shared virtual memory functionality of OpenCL 2.0. The clEnqueueSVMMigrateMem API call (OpenCL 2.1) should be integrated at the same time.

Wrap the clCloneKernel API call (OpenCL 2.1), which makes a shallow copy of the kernel object.

Many folks will probably use the example code as the basis for their first projects - which will likely have bugs in kernels.

Make life easier for them by replacing eg. this code

	ccl_program_build(prg, NULL, &err);
	HANDLE_ERROR(err);

with this code:

	ccl_program_build(prg, NULL, &err);
	if (err != NULL)
	{
		CCLErr* err2 = NULL;
		fprintf(stderr, "\n%s\nBuild Error: Log Start\n", err->message);
		char* log = ccl_program_get_build_info_array(prg, dev, CL_PROGRAM_BUILD_LOG, char*, &err2);
		fprintf(stderr, "\n%s\nBuild Log End\n", log);
		HANDLE_ERROR(err2);
	}
	HANDLE_ERROR(err);

Hello,

I have tried both compilation from scratch and https://formulae.brew.sh/formula/cf4ocl, yet. cmake. cannot link the library. Am I missing something?

Cheers.

Namely allow to configure the profiler module to use instants such as queued, submitted and complete (the latter available since OpenCL 2.0).

Specifically, test_kernel fails in test /wrappers/kernel/native in clEnqueueNativeKernel() function (ocl_enqueue.c, line *arg_loc = mem_list[i]->mem;).

Although it is perfectly possible to use OpenGL sharing with cf4ocl, it's necessary to use the appropriate OpenCL functions directly (e.g. clCreateFromGLBuffer, etc), loosing the benefits offered by cf4ocl such as error management, event wrapping or integrated profiling.

A possible prototype for such wrapper function could be:

CCLEvent* ccl_kernel_enqueue_native_full(CCLQueue* cq,
void (CL_CALLBACK user_func)(void *), CCLKernelNativeArgs args,
CCLEventWaitList evt_wait_lst, GError** err);

Some links regarding the use of clEnqueueNativeKernel():

• http://steckdenis.wordpress.com/2011/06/18/use-opencl-to-execute-native-kernels/
• http://stackoverflow.com/questions/10140494/using-clenqueuenativekernel-in-opencl
• https://github.com/pcpratts/gcc_opencl/blob/master/example.c

Wrap the clCreateProgramWithIL API call (OpenCL 2.1) which creates a program object using an IL (intermediate language, e.g. SPIR-V) memory block.

I downloaded the latest version in master branch and could build it successfully with the 1.1 embedded profile OpenCL library on a Freescale (now NXP) i.MX6Q device. The utilities are running fine and can show the device information correctly:

* Platform #0: Vivante OpenCL Platform (Vivante Corporation)
               OpenCL 1.1 , EMBEDDED_PROFILE

    [ Device #0: Vivante OpenCL Device ]

        TYPE                                 | GPU
        VENDOR                               | Vivante Corporation
        OPENCL_C_VERSION                     | OpenCL C 1.1
        MAX_COMPUTE_UNITS                    | 4
        GLOBAL_MEM_SIZE                      | 128.0 MiB (134217728 bytes)
        MAX_MEM_ALLOC_SIZE                   | 64.0 MiB (67108864 bytes)
        LOCAL_MEM_SIZE                       | 1.0 KiB (1024 bytes)
        LOCAL_MEM_TYPE                       | GLOBAL
        MAX_WORK_GROUP_SIZE                  | 1024 work-items

However, the canon example sometimes works and most times crashes (note that I added more debug output below:

Working case:

  =========================== Device Selection ============================

              0. Vivante OpenCL Device [Vivante OpenCL Platform]

 * Global worksize: 16
 * Local worksize : 16

device buffers created.
device buffer write events added to wait list...
kernel termination event added to wait list...
kernel done, wait list empty.
device result back.
Kernel exec passed result check.

perform profiling...

   =========================== Timming/Profiling ===========================

     Aggregate times by event  :
       ------------------------------------------------------------------
       | Event name                     | Rel. time (%) | Abs. time (s) |
       ------------------------------------------------------------------
       | WRITE_BUFFER                   |       58.8535 |    4.6200e-04 |
       | READ_BUFFER                    |       22.9299 |    1.8000e-04 |
       | MARKER                         |       17.4522 |    1.3700e-04 |
       | NDRANGE_KERNEL                 |        0.7643 |    6.0000e-06 |
       ------------------------------------------------------------------
                                        |         Total |    7.8500e-04 |
                                        ---------------------------------
     Event overlaps            : None
profiling result in out.tsv
host buffers destroyed.
device buffers destroyed.
memory leak check passed.

Crash case:

   =========================== Device Selection ============================

              0. Vivante OpenCL Device [Vivante OpenCL Platform]

 * Global worksize: 16
 * Local worksize : 16

device buffers created.
device buffer write events added to wait list...
kernel termination event added to wait list...
kernel done, wait list empty.
Segmentation fault (core dumped)

The crashing point looks like at the result checking stage. Not sure if this is a cf4ocl issue or FSL OpenCL library issue. Please teach if there are ways to identify it.

• Test works with OpenCL stub.
• Test fails sometimes, seg. fault
• Direct OpenCL approach seems to work, so problem must be in cf4ocl

Currently the examples have a (heavyweight) dependency of OpenMP. It would be nice to avoid this dependency by making the examples build optional in the CMake process.

In file included from /home/ubuntu/amd/opencl/compiler/llvm/tools/clang/include/clang/Frontend/ASTUnit.h:18:0,
from /home/ubuntu/amd/opencl/compiler/llvm/tools/clang/include/clang/Frontend/FrontendAction.h:24,
from /home/ubuntu/amd/opencl/compiler/llvm/tools/clang/include/clang/CodeGen/CodeGenAction.h:13,
from /home/ubuntu/amd/opencl/compiler/driver/src/driver/AmdCompiler.cpp:47:
/home/ubuntu/amd/opencl/compiler/llvm/tools/clang/include/clang/AST/ASTContext.h: In member function ‘const clang::ast_type_traits::DynTypedNode* clang::ASTContext::DynTypedNodeList::begin() const’:
/home/ubuntu/amd/opencl/compiler/llvm/tools/clang/include/clang/AST/ASTContext.h:558:13: warning: dereferencing type-punned pointer will break strict-aliasing rules [-Wstrict-aliasing]
->begin();
^
/home/ubuntu/amd/opencl/compiler/llvm/tools/clang/include/clang/AST/ASTContext.h: In member function ‘const clang::ast_type_traits::DynTypedNode* clang::ASTContext::DynTypedNodeList::end() const’:
/home/ubuntu/amd/opencl/compiler/llvm/tools/clang/include/clang/AST/ASTContext.h:565:13: warning: dereferencing type-punned pointer will break strict-aliasing rules [-Wstrict-aliasing]
->end();
^
/home/ubuntu/amd/opencl/compiler/driver/src/driver/AmdCompiler.cpp: At global scope:
/home/ubuntu/amd/opencl/compiler/driver/src/driver/AmdCompiler.cpp:108:6: error: prototype for ‘bool amd::opencl_driver::File::WriteData(const char*, size_t)’ does not match any in class ‘amd::opencl_driver::File’
bool File::WriteData(const char* ptr, size_t size)
^
In file included from /home/ubuntu/amd/opencl/compiler/driver/src/driver/AmdCompiler.cpp:1:0:
/home/ubuntu/amd/opencl/compiler/driver/src/driver/AmdCompiler.h:85:8: error: candidate is: bool amd::opencl_driver::File::WriteData(const char*, int)
bool WriteData(const char* ptr, size_t size);
^
/home/ubuntu/amd/opencl/compiler/driver/src/driver/AmdCompiler.cpp: In member function ‘virtual amd::opencl_driver::FileReference* amd::opencl_driver::BufferReference::ToInputFile(amd::opencl_driver::Compiler*, amd::opencl_driver::File*)’:
/home/ubuntu/amd/opencl/compiler/driver/src/driver/AmdCompiler.cpp:170:26: error: ‘size’ was not declared in this scope
if (!f->WriteData(ptr, size)) { return 0; }
^
/home/ubuntu/amd/opencl/compiler/driver/src/driver/AmdCompiler.cpp: At global scope:
/home/ubuntu/amd/opencl/compiler/driver/src/driver/AmdCompiler.cpp:315:20: error: ‘amd::opencl_driver::BufferReference* amd::opencl_driver::AMDGPUCompiler::NewBufferReference(amd::opencl_driver::DataType, const char*, size_t, const string&)’ marked ‘override’, but does not override
BufferReference* NewBufferReference(DataType type, const char* ptr, size_t size, const std::string& id) override;
^
/home/ubuntu/amd/opencl/compiler/driver/src/driver/AmdCompiler.cpp: In member function ‘virtual bool amd::opencl_driver::AMDGPUCompiler::DumpExecutableAsText(amd::opencl_driver::Buffer*, amd::opencl_driver::File*)’:
/home/ubuntu/amd/opencl/compiler/driver/src/driver/AmdCompiler.cpp:710:40: error: ‘class amd::opencl_driver::Buffer’ has no member named ‘Size’
StringRef execRef(exec->Ptr(), exec->Size());
^
/home/ubuntu/amd/opencl/compiler/driver/src/driver/AmdCompiler.cpp: In member function ‘amd::opencl_driver::Compiler* amd::opencl_driver::CompilerFactory::CreateAMDGPUCompiler(const string&)’:
/home/ubuntu/amd/opencl/compiler/driver/src/driver/AmdCompiler.cpp:761:36: error: invalid new-expression of abstract class type ‘amd::opencl_driver::AMDGPUCompiler’
return new AMDGPUCompiler(llvmBin);
^
/home/ubuntu/amd/opencl/compiler/driver/src/driver/AmdCompiler.cpp:266:7: note: because the following virtual functions are pure within ‘amd::opencl_driver::AMDGPUCompiler’:
class AMDGPUCompiler : public Compiler {
^
In file included from /home/ubuntu/amd/opencl/compiler/driver/src/driver/AmdCompiler.cpp:1:0:
/home/ubuntu/amd/opencl/compiler/driver/src/driver/AmdCompiler.h:194:28: note: virtual amd::opencl_driver::BufferReference* amd::opencl_driver::Compiler::NewBufferReference(amd::opencl_driver::DataType, const char*, int, const string&)
virtual BufferReference* NewBufferReference(DataType type, const char* ptr, size_t size, const std::string& id = "") = 0;
^
compiler/driver/src/driver/CMakeFiles/opencl_driver.dir/build.make:62: recipe for target 'compiler/driver/src/driver/CMakeFiles/opencl_driver.dir/AmdCompiler.cpp.o' failed
make[2]: *** [compiler/driver/src/driver/CMakeFiles/opencl_driver.dir/AmdCompiler.cpp.o] Error 1
CMakeFiles/Makefile2:19547: recipe for target 'compiler/driver/src/driver/CMakeFiles/opencl_driver.dir/all' failed
make[1]: *** [compiler/driver/src/driver/CMakeFiles/opencl_driver.dir/all] Error 2
Makefile:149: recipe for target 'all' failed
make: *** [all] Error 2

This will require at least a wrapper for the clCreateSubDevices() function.

OpenCL 2.0 and higher do not require that global work size be a multiple of the local work size. Reflect this in the ccl_kernel_suggest_worksizes function.

ccl_program_enqueue_kernel fails when invoked without kernel arguments

This problem seems to be related with issue #11

Create a module/class with wrapper methods for the Pipes functionality of OpenCL 2.0.

Allow developers to register a callback function invoked on g_error macro invocations stack traces

By composite events I mean user defined virtual events that start with one OpenCL event (e.g. enqueue_map.start) and stop with another (e.g. enqueue_unmap.stop).

Wrap the clGetKernelSubGroupInfo API call (OpenCL 2.1), which queries kernels concerning sub-groups present in each work-group for a given local work size.

This would allow developers to use and reference/dereference raw OpenCL objects outside of cf4ocl with increased safety.

Although it is perfectly possible to use DirectX sharing with cf4ocl, it's necessary to use the appropriate OpenCL functions directly (e.g. clGetDeviceIDsFromD3D10KHR, etc), loosing the benefits offered by cf4ocl such as error management, event wrapping or integrated profiling.

On Linux it's possible to have an ICD Loader library installed, which can be used to load any OpenCL implementation. If no actual implementation exists, cf4ocl calls will segfault, which should be avoided.

test_kernel and test_program crash when compiled for 32-bits with Visual Studio. This only happens for real OCL implementations (only AMD CPU impl. tested so far), it works with the OCL stub. Tests work fine when built for 64-bits.

The ccl_devinfo and ccl_kerninfo utilities crash when compiled with Visual Studio. This occurs for both 32 and 64-bit builds. The utilities work fine when compiled with MinGW.

Wrap the clSetDefaultDeviceCommandQueue API call (OpenCL 2.1), which replaces the default command queue on the device.

Seems to be related with issue #11

Wrap the clGetHostTimer and clGetDeviceAndHostTimer API calls (OpenCL 2.1). The former returns the current value of the host clock as seen by device, while the latter returns a reasonably synchronized pair of timestamps from the device timer and the host timer as seen by device.

This functionality should be integrated in the cf4ocl profiler module, with care taken to consider the new CL_PLATFORM_HOST_TIMER_RESOLUTION platform info query.

• Only occurs in 64-bit builds and tested against the OpenCL stub.
• Test works fine with real OpenCL implementations.
• Some sort of infinite loop.

For many GPUs (IoT devices using unified memory models, Intel iGPUs, and GPUs with pinned memory), zero-copy buffers are really useful. You use malloc() in the examples currently, which only aligns to 8-byte boundaries typically. Intel requires 4096-byte boundaries, ARM usually requires 64-bytes, etc. Unfortunately Windows uses different alignment methods than Linux, but this stackoverflow question gives a nice example of how to #ifdef wrap a mimic of posix_memalign : https://stackoverflow.com/a/33696858 and https://stackoverflow.com/a/38291021

To make life easy for people you could create a function that extracts CL_DEVICE_MEM_BASE_ADDR_ALIGN and uses this to correctly align buffers (and have a corresponding free call, to abstract windows/linux differences).

• Tests work with OpenCL stub, they only fail with a real OpenCL implementation (only tested against AMD CPU implementation).
• Tests involving callbacks: test_buffer, test_event

Fix/clarify issues highlighted by Coverity. This will be an ongoing open issue. Comments will reflect improvements.

Improve test coverage reported by Codecov. This will be an ongoing open issue. Comments will reflect coverage improvements.

Utility for static compilation of OpenCL kernels.

The CL_PROFILING_COMMAND_COMPLETE, introduced in OpenCL 2.0, describes the current device time counter in nanoseconds when the command identified by event and any child commands enqueued by this command on the device have finished execution.

Add support for this profiling info to the cf4ocl profiler.