internal static extern ErrorCode clEnqueueReleaseGLObjects(
cl_command_queue command_queue,
cl_uint num_objects,
[In] cl_mem[] mem_objects,
cl_uint num_events_in_wait_list,
[In] cl_event[] event_wait_list,
cl_event *_event);
internal static extern ErrorCode clEnqueueUnmapMemObject(
cl_command_queue command_queue,
cl_mem memobj,
void *mapped_ptr,
cl_uint num_events_in_wait_list,
IntPtr *event_wait_list,
cl_event *_event);
internal static extern ErrorCode clEnqueueUnmapMemObject(
cl_command_queue command_queue,
cl_mem memobj,
void *mapped_ptr,
cl_uint num_events_in_wait_list,
[In][MarshalAs(UnmanagedType.LPArray)] cl_event[] event_wait_list,
cl_event *_event);
/// <summary>
/// Create OpenCL device
/// </summary>
/// <param name="clEnv">OpenCL environment</param>
public clDevice(clEnvironment clEnv)
{
env = clEnv;
cq = cl.CreateCommandQueue(env.context, env.device);
vectorProgram = loadProgram(clVectorSource.source);
matrixProgram = loadProgram(clMatrixSource.source);
}
internal static extern ErrorCode clEnqueueCopyBufferToImage(
cl_command_queue command_queue,
cl_mem src_buffer,
cl_mem dst_image,
IntPtr src_offset,
IntPtr *dst_origin,
IntPtr *region,
cl_uint num_events_in_wait_list,
IntPtr *event_wait_list,
cl_event *_event);
internal static extern ErrorCode clEnqueueCopyBufferToImage(
cl_command_queue command_queue,
cl_mem src_buffer,
cl_mem dst_image,
IntPtr src_offset,
[In][MarshalAs(UnmanagedType.LPArray, SizeConst = 3)] IntPtr[] dst_origin,
[In][MarshalAs(UnmanagedType.LPArray, SizeConst = 3)] IntPtr[] region,
cl_uint num_events_in_wait_list,
[In][MarshalAs(UnmanagedType.LPArray)] cl_event[] event_wait_list,
cl_event *_event);
internal static extern ErrorCode clEnqueueWriteBuffer(
cl_command_queue command_queue,
cl_mem buffer,
cl_bool blocking_write,
IntPtr offset,
IntPtr cb,
void *ptr,
cl_uint num_events_in_wait_list,
[In][MarshalAs(UnmanagedType.LPArray)] cl_event[] event_wait_list,
cl_event *_event);
internal static extern ErrorCode clEnqueueNDRangeKernel(
cl_command_queue command_queue,
cl_kernel kernel,
cl_uint work_dim,
IntPtr *global_work_offset,
IntPtr *global_work_size,
IntPtr *local_work_size,
cl_uint num_events_in_wait_list,
IntPtr *event_wait_list,
cl_event *_event);
internal static extern ErrorCode clEnqueueCopyBuffer(
cl_command_queue command_queue,
cl_mem src_buffer,
cl_mem dst_buffer,
IntPtr src_offset,
IntPtr dst_offset,
IntPtr cb,
cl_uint num_events_in_wait_list,
IntPtr *event_wait_list,
cl_event *_event);
internal static extern ErrorCode clEnqueueCopyBuffer(
cl_command_queue command_queue,
cl_mem src_buffer,
cl_mem dst_buffer,
IntPtr src_offset,
IntPtr dst_offset,
IntPtr cb,
cl_uint num_events_in_wait_list,
[In][MarshalAs(UnmanagedType.LPArray)] cl_event[] event_wait_list,
cl_event *_event);
internal static extern ErrorCode clEnqueueWriteBuffer(
cl_command_queue command_queue,
cl_mem buffer,
cl_bool blocking_write,
IntPtr offset,
IntPtr cb,
void *ptr,
cl_uint num_events_in_wait_list,
IntPtr *event_wait_list,
cl_event *_event);
internal static extern ErrorCode clEnqueueNDRangeKernel(
cl_command_queue command_queue,
cl_kernel kernel,
cl_uint work_dim,
[In][MarshalAs(UnmanagedType.LPArray)] IntPtr[] global_work_offset,
[In][MarshalAs(UnmanagedType.LPArray)] IntPtr[] global_work_size,
[In][MarshalAs(UnmanagedType.LPArray)] IntPtr[] local_work_size,
cl_uint num_events_in_wait_list,
[In][MarshalAs(UnmanagedType.LPArray)] cl_event[] event_wait_list,
cl_event *_event);
internal static extern void *clEnqueueMapBuffer(
cl_command_queue command_queue,
cl_mem buffer,
cl_bool blocking_map,
cl_map_flags map_flags,
IntPtr offset,
IntPtr cb,
cl_uint num_events_in_wait_list,
IntPtr *event_wait_list,
cl_event *_event,
out ErrorCode errcode_ret);
internal static extern ErrorCode clEnqueueNativeKernel(
cl_command_queue command_queue,
NativeKernelInternal user_func,
void *args,
IntPtr cb_args,
cl_uint num_mem_objects,
[In] cl_mem[] mem_list,
[In][MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 4)] IntPtr[] args_mem_loc,
cl_uint num_events_in_wait_list,
[In][MarshalAs(UnmanagedType.LPArray)] cl_event[] event_wait_list,
cl_event *_event);
internal static extern void *clEnqueueMapBuffer(
cl_command_queue command_queue,
cl_mem buffer,
cl_bool blocking_map,
cl_map_flags map_flags,
IntPtr offset,
IntPtr cb,
cl_uint num_events_in_wait_list,
[In][MarshalAs(UnmanagedType.LPArray)] cl_event[] event_wait_list,
cl_event *_event,
out ErrorCode errcode_ret);
internal static extern ErrorCode clEnqueueWriteImage(
cl_command_queue command_queue,
cl_mem image,
cl_bool blocking_write,
IntPtr *origin,
IntPtr *region,
IntPtr input_row_pitch,
IntPtr input_slice_pitch,
void *ptr,
cl_uint num_events_in_wait_list,
IntPtr *event_wait_list,
cl_event *_event);
internal static extern ErrorCode clEnqueueWriteImage(
cl_command_queue command_queue,
cl_mem image,
cl_bool blocking_write,
[In][MarshalAs(UnmanagedType.LPArray, SizeConst = 3)] IntPtr[] origin,
[In][MarshalAs(UnmanagedType.LPArray, SizeConst = 3)] IntPtr[] region,
IntPtr input_row_pitch,
IntPtr input_slice_pitch,
void *ptr,
cl_uint num_events_in_wait_list,
[In][MarshalAs(UnmanagedType.LPArray)] cl_event[] event_wait_list,
cl_event *_event);
internal static extern void *clEnqueueMapImage(
cl_command_queue command_queue,
cl_mem image,
cl_bool blocking_map,
cl_map_flags map_flags,
IntPtr *origin,
IntPtr *region,
out IntPtr image_row_pitch,
out IntPtr image_slice_pitch,
cl_uint num_events_in_wait_list,
IntPtr *event_wait_list,
cl_event *_event,
out ErrorCode errcode_ret);
internal static extern void *clEnqueueMapImage(
cl_command_queue command_queue,
cl_mem image,
cl_bool blocking_map,
cl_map_flags map_flags,
[In][MarshalAs(UnmanagedType.LPArray, SizeConst = 3)] IntPtr[] origin,
[In][MarshalAs(UnmanagedType.LPArray, SizeConst = 3)] IntPtr[] region,
out IntPtr image_row_pitch,
out IntPtr image_slice_pitch,
cl_uint num_events_in_wait_list,
[In][MarshalAs(UnmanagedType.LPArray)] cl_event[] event_wait_list,
cl_event *_event,
out ErrorCode errcode_ret);
internal static extern ErrorCode clEnqueueCopyBufferRect(
cl_command_queue command_queue,
cl_mem src_buffer,
cl_mem dst_buffer,
IntPtr *src_origin,
IntPtr *dst_origin,
IntPtr *region,
IntPtr src_row_pitch,
IntPtr src_slice_pitch,
IntPtr dst_row_pitch,
IntPtr dst_slice_pitch,
cl_uint num_events_in_wait_list,
cl_event *_event_wait_list,
cl_event *_event);
internal static extern ErrorCode clEnqueueCopyBufferRect(
cl_command_queue command_queue,
cl_mem src_buffer,
cl_mem dst_buffer,
[In] IntPtr[] src_origin,
[In] IntPtr[] dst_origin,
[In] IntPtr[] region,
IntPtr src_row_pitch,
IntPtr src_slice_pitch,
IntPtr dst_row_pitch,
IntPtr dst_slice_pitch,
cl_uint num_events_in_wait_list,
[In][MarshalAs(UnmanagedType.LPArray)] cl_event[] _event_wait_list,
cl_event *_event);
internal static extern ErrorCode clEnqueueWriteBufferRect(
cl_command_queue command_queue,
cl_mem buffer,
cl_bool blocking_write,
[In] IntPtr[] buffer_offset,
[In] IntPtr[] host_offset,
[In] IntPtr[] region,
IntPtr buffer_row_pitch,
IntPtr buffer_slice_pitch,
IntPtr host_row_pitch,
IntPtr host_slice_pitch,
void *ptr,
cl_uint num_events_in_wait_list,
[In][MarshalAs(UnmanagedType.LPArray)] cl_event[] _event_wait_list,
cl_event *_event);
internal static extern ErrorCode clEnqueueWriteBufferRect(
cl_command_queue command_queue,
cl_mem buffer,
cl_bool blocking_write,
IntPtr *buffer_offset,
IntPtr *host_offset,
IntPtr *region,
IntPtr buffer_row_pitch,
IntPtr buffer_slice_pitch,
IntPtr host_row_pitch,
IntPtr host_slice_pitch,
void *ptr,
cl_uint num_events_in_wait_list,
cl_event *_event_wait_list,
cl_event *_event);
public static ErrorCode EnqueueNativeKernel(cl_command_queue command_queue,
NativeKernelInternal user_func,
void *args,
IntPtr cb_args,
cl_uint num_mem_objects,
cl_mem[] mem_list,
IntPtr[] args_mem_loc,
cl_uint num_events_in_wait_list,
cl_event[] event_wait_list,
cl_event *_event)
{
return(OpenCLAPI.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));
}
public static void Main()
{
const int cnBlockSize = 4;
const int cnBlocks = 3;
IntPtr cnDimension = new IntPtr(cnBlocks * cnBlockSize);
string sProgramSource = @"
__kernel void
vectorAdd(__global const float * a,
__global const float * b,
__global float * c)
{
// Vector element index
int nIndex = get_global_id(0);
c[nIndex] = a[nIndex] + b[nIndex];
}
";
ErrorCode error;
// create OpenCL device & context
cl_context hContext;
unsafe { hContext = CL.CreateContextFromType((ContextProperties *)null, DeviceTypeFlags.DeviceTypeDefault, IntPtr.Zero, IntPtr.Zero, &error); }
// query all devices available to the context
IntPtr nContextDescriptorSize;
CL.GetContextInfo(hContext, ContextInfo.ContextDevices, IntPtr.Zero, IntPtr.Zero, out nContextDescriptorSize);
cl_device_id[] aDevices = new cl_device_id[nContextDescriptorSize.ToInt32()];
unsafe
{
fixed(cl_device_id *ptr = aDevices)
{
IntPtr ret;
CL.GetContextInfo(hContext, ContextInfo.ContextDevices, nContextDescriptorSize, new IntPtr(ptr), out ret);
}
}
// create a command queue for first device the context reported
cl_command_queue hCmdQueue = CL.CreateCommandQueue(hContext, aDevices[0], (CommandQueueFlags)0, out error);
// create & compile program
cl_program hProgram;
unsafe { hProgram = CL.CreateProgramWithSource(hContext, 1, new string[] { sProgramSource }, null, &error); }
CL.BuildProgram(hProgram, 0, (IntPtr[])null, null, IntPtr.Zero, IntPtr.Zero);
// create kernel
cl_kernel hKernel = CL.CreateKernel(hProgram, "vectorAdd", out error);
// allocate host vectors
float[] A = new float[cnDimension.ToInt32()];
float[] B = new float[cnDimension.ToInt32()];
float[] C = new float[cnDimension.ToInt32()];
// initialize host memory
Random rand = new Random();
for (int i = 0; i < A.Length; i++)
{
A[i] = rand.Next() % 256;
B[i] = rand.Next() % 256;
}
// allocate device memory
unsafe
{
fixed(float *pA = A)
fixed(float *pB = B)
fixed(float *pC = C)
{
cl_mem hDeviceMemA, hDeviceMemB, hDeviceMemC;
hDeviceMemA = CL.CreateBuffer(hContext,
MemFlags.MemReadOnly | MemFlags.MemCopyHostPtr,
new IntPtr(cnDimension.ToInt32() * sizeof(float)),
new IntPtr(pA),
out error);
hDeviceMemB = CL.CreateBuffer(hContext,
MemFlags.MemReadOnly | MemFlags.MemCopyHostPtr,
new IntPtr(cnDimension.ToInt32() * sizeof(float)),
new IntPtr(pA),
out error);
hDeviceMemC = CL.CreateBuffer(hContext,
MemFlags.MemWriteOnly,
new IntPtr(cnDimension.ToInt32() * sizeof(float)),
IntPtr.Zero,
out error);
// setup parameter values
CL.SetKernelArg(hKernel, 0, new IntPtr(sizeof(cl_mem)), new IntPtr(&hDeviceMemA));
CL.SetKernelArg(hKernel, 1, new IntPtr(sizeof(cl_mem)), new IntPtr(&hDeviceMemB));
CL.SetKernelArg(hKernel, 2, new IntPtr(sizeof(cl_mem)), new IntPtr(&hDeviceMemC));
// write data from host to device
CL.EnqueueWriteBuffer(hCmdQueue, hDeviceMemA, true, IntPtr.Zero,
new IntPtr(cnDimension.ToInt32() * sizeof(float)),
new IntPtr(pA), 0, null, (IntPtr[])null);
CL.EnqueueWriteBuffer(hCmdQueue, hDeviceMemB, true, IntPtr.Zero,
new IntPtr(cnDimension.ToInt32() * sizeof(float)),
new IntPtr(pB), 0, null, (IntPtr[])null);
// execute kernel
error = (ErrorCode)CL.EnqueueNDRangeKernel(hCmdQueue, hKernel, 1, null, &cnDimension, null, 0, null, null);
if (error != ErrorCode.Success)
{
throw new Exception(error.ToString());
}
// copy results from device back to host
IntPtr event_handle = IntPtr.Zero;
error = (ErrorCode)CL.EnqueueReadBuffer(hCmdQueue, hDeviceMemC, true, IntPtr.Zero,
new IntPtr(cnDimension.ToInt32() * sizeof(float)),
new IntPtr(pC), 0, null, (IntPtr[])null);
if (error != ErrorCode.Success)
{
throw new Exception(error.ToString());
}
CL.Finish(hCmdQueue);
CL.ReleaseMemObject(hDeviceMemA);
CL.ReleaseMemObject(hDeviceMemB);
CL.ReleaseMemObject(hDeviceMemC);
}
}
for (int i = 0; i < A.Length; i++)
{
System.Diagnostics.Trace.WriteLine(String.Format("{0} + {1} = {2}", A[i], B[i], C[i]));
}
}
internal static extern ErrorCode clEnqueueMarker(cl_command_queue command_queue, cl_event *_event);
internal static extern ErrorCode clEnqueueWaitForEvents(
cl_command_queue command_queue,
cl_uint num_events,
[In][MarshalAs(UnmanagedType.LPArray)] cl_event[] _event_list);
internal static extern ErrorCode clFinish(cl_command_queue command_queue);
internal static extern ErrorCode clEnqueueWaitForEvents(
cl_command_queue command_queue,
cl_uint num_events,
IntPtr *_event_list);
internal static extern ErrorCode clEnqueueBarrier(cl_command_queue command_queue);
