public void initialize()
{
ErrorCode errorCode;
// http://www.codeproject.com/Articles/502829/GPGPU-image-processing-basics-using-OpenCL-NET
// license The Code Project Open License (CPOL)
// snip ===
OpenCL.Net.Platform[] platforms = Cl.GetPlatformIDs(out errorCode);
if (errorCode != ErrorCode.Success)
{
throw new OpenClError();
}
List<OpenCL.Net.Device> devicesList = new List<OpenCL.Net.Device>();
foreach (OpenCL.Net.Platform platform in platforms)
{
string platformName = Cl.GetPlatformInfo(platform, OpenCL.Net.PlatformInfo.Name, out errorCode).ToString();
if (errorCode != ErrorCode.Success)
{
throw new OpenClError();
}
Console.WriteLine("Platform: " + platformName);
//We will be looking only for GPU devices
foreach (OpenCL.Net.Device device in Cl.GetDeviceIDs(platform, OpenCL.Net.DeviceType.Gpu, out errorCode))
{
if (errorCode != ErrorCode.Success)
{
throw new OpenClError();
}
Console.WriteLine("Device: " + device.ToString());
devicesList.Add(device);
}
}
if (devicesList.Count <= 0)
{
Console.WriteLine("No devices found.");
throw new OpenClError();
}
chosenDevice = devicesList[1];
// end snip ===
context = Cl.CreateContext(null, 1, new Device[] { chosenDevice }, null, IntPtr.Zero, out errorCode);
if (errorCode != ErrorCode.Success)
{
throw new OpenClError();
}
commandQueue = Cl.CreateCommandQueue(context, chosenDevice, CommandQueueProperties.OutOfOrderExecModeEnable, out errorCode);
if (errorCode != ErrorCode.Success)
{
throw new OpenClError();
}
}
private OpenCL.Net.Event run(OpenCL.Net.CommandQueue commandQueue, OpenCL.Net.IMem srcImg, OpenCL.Net.IMem dstImg, uint globalWorkSize0, uint globalWorkSize1 = 0, uint globalWorkSize2 = 0, uint localWorkSize0 = 0, uint localWorkSize1 = 0, uint localWorkSize2 = 0, params OpenCL.Net.Event[] waitFor)
{
OpenCL.Net.Cl.SetKernelArg(this.Kernel, 0, srcImg);
OpenCL.Net.Cl.SetKernelArg(this.Kernel, 1, dstImg);
OpenCL.Net.Event ev;
OpenCL.Net.ErrorCode err;
err = OpenCL.Net.Cl.EnqueueNDRangeKernel(commandQueue, this.Kernel, base.GetWorkDimension(globalWorkSize0, globalWorkSize1, globalWorkSize2), null, base.GetWorkSizes(globalWorkSize0, globalWorkSize1, globalWorkSize2), base.GetWorkSizes(localWorkSize0, localWorkSize1, localWorkSize2), ((uint)(waitFor.Length)), waitFor.Length == 0 ? null : waitFor, out ev);
OpenCL.Net.Cl.Check(err);
return(ev);
}
private OpenCL.Net.Event run(OpenCL.Net.CommandQueue commandQueue, OpenCL.Net.IMem <System.Single> a, OpenCL.Net.IMem <System.Single> b, int local_length, float scale, uint globalWorkSize0, uint globalWorkSize1 = 0, uint globalWorkSize2 = 0, uint localWorkSize0 = 0, uint localWorkSize1 = 0, uint localWorkSize2 = 0, params OpenCL.Net.Event[] waitFor)
{
OpenCL.Net.Cl.SetKernelArg(this.Kernel, 0, a);
OpenCL.Net.Cl.SetKernelArg(this.Kernel, 1, b);
OpenCL.Net.Cl.SetKernelArg(this.Kernel, 2, ((System.IntPtr)((local_length * OpenCL.Net.TypeSize <uchar3> .SizeInt))), null);
OpenCL.Net.Cl.SetKernelArg(this.Kernel, 3, scale);
OpenCL.Net.Event ev;
OpenCL.Net.ErrorCode err;
err = OpenCL.Net.Cl.EnqueueNDRangeKernel(commandQueue, this.Kernel, base.GetWorkDimension(globalWorkSize0, globalWorkSize1, globalWorkSize2), null, base.GetWorkSizes(globalWorkSize0, globalWorkSize1, globalWorkSize2), base.GetWorkSizes(localWorkSize0, localWorkSize1, localWorkSize2), ((uint)(waitFor.Length)), waitFor.Length == 0 ? null : waitFor, out ev);
OpenCL.Net.Cl.Check(err);
return(ev);
}
public CommandQueue(ComputeProvider provider, ClNet.Device device, bool outOfOrderExecution = false)
{
ClNet.ErrorCode error;
_queue = Cl.CreateCommandQueue
(provider.Context
, device
, outOfOrderExecution
? ClNet.CommandQueueProperties.OutOfOrderExecModeEnable
: ClNet.CommandQueueProperties.None, out error);
if (error != ClNet.ErrorCode.Success)
throw new Cl.Exception(error);
}
public CommandQueue(ComputeProvider provider, ClNet.Device device, bool outOfOrderExecution = false)
{
ClNet.ErrorCode error;
_queue = Cl.CreateCommandQueue
(provider.Context
, device
, outOfOrderExecution
? ClNet.CommandQueueProperties.OutOfOrderExecModeEnable
: ClNet.CommandQueueProperties.None, out error);
if (error != ClNet.ErrorCode.Success)
{
throw new Cl.Exception(error);
}
}
public void SquareArray(float[] array)
{
Cl.ErrorCode error;
//Create the required kernel (entry function)
Cl.Kernel kernel = Cl.Cl.CreateKernel(_program, "square_array", out error);
CheckErr(error, "Cl.CreateKernel");
int intPtrSize = 0;
intPtrSize = Marshal.SizeOf(typeof(IntPtr));
var arrayBuffer = Cl.Cl.CreateBuffer <float>(_context, Cl.MemFlags.CopyHostPtr | Cl.MemFlags.ReadWrite, array, out error);
CheckErr(error, "Cl.CreateBuffer plaintext_bytes");
//Pass the memory buffers to our kernel function
error = Cl.Cl.SetKernelArg(kernel, 0, (IntPtr)intPtrSize, arrayBuffer);
CheckErr(error, "Cl.SetKernelArg");
//Create a command queue, where all of the commands for execution will be added
Cl.CommandQueue cmdQueue = Cl.Cl.CreateCommandQueue(_context, _device, (Cl.CommandQueueProperties) 0, out error);
CheckErr(error, "Cl.CreateCommandQueue");
Cl.Event clevent;
IntPtr[] workGroupSizePtr = new IntPtr[] { (IntPtr)array.Length };
//Execute our kernel (OpenCL code)
error = Cl.Cl.EnqueueNDRangeKernel(cmdQueue, kernel, 1, null, workGroupSizePtr, null, 0, null, out clevent);
CheckErr(error, "Cl.EnqueueNDRangeKernel");
//Wait for completion of all calculations on the GPU.
error = Cl.Cl.Finish(cmdQueue);
CheckErr(error, "Cl.Finish");
// Read the buffer from memory
error = Cl.Cl.EnqueueReadBuffer(cmdQueue, arrayBuffer, Cl.Bool.True, array, 0, null, out clevent);
CheckErr(error, "Cl.EnqueueReadBuffer");
//Clean up memory
Cl.Cl.ReleaseKernel(kernel);
Cl.Cl.ReleaseCommandQueue(cmdQueue);
Cl.Cl.ReleaseMemObject(arrayBuffer);
}
public OpenCL.Net.Event EnqueueRun(OpenCL.Net.CommandQueue commandQueue, OpenCL.Net.IMem srcImg, OpenCL.Net.IMem dstImg, uint globalWorkSize0, uint globalWorkSize1, uint globalWorkSize2, uint localWorkSize0 = 0, uint localWorkSize1 = 0, uint localWorkSize2 = 0, params OpenCL.Net.Event[] waitFor)
{
return(this.run(commandQueue, srcImg, dstImg, globalWorkSize0: globalWorkSize0, globalWorkSize1: globalWorkSize1, globalWorkSize2: globalWorkSize2, localWorkSize0: localWorkSize0, localWorkSize1: localWorkSize1, localWorkSize2: localWorkSize2, waitFor: waitFor));
}
public void Run(OpenCL.Net.CommandQueue commandQueue, OpenCL.Net.IMem srcImg, OpenCL.Net.IMem dstImg, uint globalWorkSize0, uint globalWorkSize1, uint globalWorkSize2, uint localWorkSize0 = 0, uint localWorkSize1 = 0, uint localWorkSize2 = 0, params OpenCL.Net.Event[] waitFor)
{
OpenCL.Net.Event ev = this.run(commandQueue, srcImg, dstImg, globalWorkSize0: globalWorkSize0, globalWorkSize1: globalWorkSize1, globalWorkSize2: globalWorkSize2, localWorkSize0: localWorkSize0, localWorkSize1: localWorkSize1, localWorkSize2: localWorkSize2, waitFor: waitFor);
ev.Wait();
}
public int[] ClosestPoints(double[,] source_points, double[,] target_points)
{
System.Diagnostics.Trace.Assert(source_points.GetLength(1) == target_points.GetLength(1));
int[] ans = new int[source_points.GetLength(0)];
CL.ErrorCode error;
byte[] source_points_byte_array = new byte[Marshal.SizeOf(typeof(double)) * source_points.Length];
byte[] target_points_byte_array = new byte[Marshal.SizeOf(typeof(double)) * target_points.Length];
byte[] dims_byte_array = new byte[Marshal.SizeOf(typeof(int)) * 3];
byte[] output_byte_array = new byte[Marshal.SizeOf(typeof(int)) * ans.Length];
int[] dims = new[] { source_points.GetLength(1), source_points.GetLength(0), target_points.GetLength(0) };
MyCL.memcpy(ref source_points, ref source_points_byte_array);
MyCL.memcpy(ref target_points, ref target_points_byte_array);
MyCL.memcpy(ref dims, ref dims_byte_array);
lock (cl_lock)
{
if (!program_initialized)
{
program_initialized = true;
string programPath = Path.Combine(Environment.CurrentDirectory, "../../ClosestPoints.cl");
if (!File.Exists(programPath))
{
throw new Exception("Program doesn't exist at path " + programPath);
}
string programSource = System.IO.File.ReadAllText(programPath);
program = CL.Cl.CreateProgramWithSource(MyCL.context, 1, new[] { programSource }, null, out error);
MyCL.CheckErr(error, "Cl.CreateProgramWithSource");
error = CL.Cl.BuildProgram(program, 1, new[] { MyCL.device }, string.Empty, null, IntPtr.Zero);
MyCL.CheckErr(error, "Cl.BuildProgram");
if (CL.Cl.GetProgramBuildInfo(program, MyCL.device, CL.ProgramBuildInfo.Status, out error).CastTo <CL.BuildStatus>() != CL.BuildStatus.Success)
{
MyCL.CheckErr(error, "Cl.GetProgramBuildInfo");
throw new Exception($"Cl.GetProgramBuildInfo != Success\r\n{CL.Cl.GetProgramBuildInfo(program, MyCL.device, CL.ProgramBuildInfo.Log, out error)}");
}
}
using (CL.Kernel kernel = CL.Cl.CreateKernel(program, "weighted_sum", out error))
{
MyCL.CheckErr(error, "Cl.CreateKernel");
//OpenCL memory buffer that will keep our image's byte[] data.
using (CL.IMem
source_points_buffer = CL.Cl.CreateBuffer(MyCL.context, CL.MemFlags.CopyHostPtr | CL.MemFlags.ReadOnly, source_points_byte_array, out CL.ErrorCode err1),
target_points_buffer = CL.Cl.CreateBuffer(MyCL.context, CL.MemFlags.CopyHostPtr | CL.MemFlags.ReadOnly, target_points_byte_array, out CL.ErrorCode err2),
dims_buffer = CL.Cl.CreateBuffer(MyCL.context, CL.MemFlags.CopyHostPtr | CL.MemFlags.ReadOnly, dims_byte_array, out CL.ErrorCode err3),
output_buffer = CL.Cl.CreateBuffer(MyCL.context, CL.MemFlags.CopyHostPtr | CL.MemFlags.WriteOnly, output_byte_array, out CL.ErrorCode err4))
{
MyCL.CheckErr(err1, "Cl.CreateBuffer source_points");
MyCL.CheckErr(err2, "Cl.CreateBuffer target_points");
MyCL.CheckErr(err3, "Cl.CreateBuffer dims");
MyCL.CheckErr(err4, "Cl.CreateBuffer output");
int intPtrSize = Marshal.SizeOf(typeof(IntPtr));
error =
CL.Cl.SetKernelArg(kernel, 0, (IntPtr)intPtrSize, source_points_buffer) |
CL.Cl.SetKernelArg(kernel, 1, (IntPtr)intPtrSize, target_points_buffer) |
CL.Cl.SetKernelArg(kernel, 2, (IntPtr)intPtrSize, dims_buffer) |
CL.Cl.SetKernelArg(kernel, 3, (IntPtr)intPtrSize, output_buffer);
MyCL.CheckErr(error, "Cl.SetKernelArg");
//Create a command queue, where all of the commands for execution will be added
using (CL.CommandQueue cmdQueue = CL.Cl.CreateCommandQueue(MyCL.context, MyCL.device, (CL.CommandQueueProperties) 0, out error))
{
MyCL.CheckErr(error, "Cl.CreateCommandQueue");
CL.Event clevent;
IntPtr[] workGroupSizePtr = new IntPtr[] { (IntPtr)source_points.GetLength(0) };
error = CL.Cl.EnqueueNDRangeKernel(
cmdQueue,
kernel,
1,
null,//not used
workGroupSizePtr, null, 0, null, out clevent);
CL.Cl.ReleaseEvent(clevent);
MyCL.CheckErr(error, "Cl.EnqueueNDRangeKernel");
error = CL.Cl.Finish(cmdQueue);
MyCL.CheckErr(error, "Cl.Finish");
error = CL.Cl.EnqueueReadBuffer(cmdQueue, output_buffer, CL.Bool.True, 0, Marshal.SizeOf(typeof(byte)) * output_byte_array.Length, output_byte_array, 0, null, out clevent);
CL.Cl.ReleaseEvent(clevent);
MyCL.CheckErr(error, "Cl.EnqueueReadBuffer");
MyCL.memcpy(ref output_byte_array, ref ans);
//CL.Cl.ReleaseCommandQueue(cmdQueue);
}
//CL.Cl.ReleaseMemObject(data_buffer);
//CL.Cl.ReleaseMemObject(offsets_x_buffer);
//CL.Cl.ReleaseMemObject(offsets_y_buffer);
//CL.Cl.ReleaseMemObject(weights_buffer);
//CL.Cl.ReleaseMemObject(dims_buffer);
//CL.Cl.ReleaseMemObject(output_buffer);
}
//CL.Cl.ReleaseKernel(kernel);
}
}
return(ans);
}
public static InfoBuffer GetCommandQueueInfo(CommandQueue commandQueue, CommandQueueInfo paramName, out ErrorCode error)
{
return(GetInfo(GetCommandQueueInfo, commandQueue, paramName, out error));
}
public OpenCL.Net.Event EnqueueRun(OpenCL.Net.CommandQueue commandQueue, OpenCL.Net.IMem <System.Single> a, OpenCL.Net.IMem <System.Single> b, int local_length, float scale, uint globalWorkSize0, uint globalWorkSize1, uint globalWorkSize2, uint localWorkSize0 = 0, uint localWorkSize1 = 0, uint localWorkSize2 = 0, params OpenCL.Net.Event[] waitFor)
{
return(this.run(commandQueue, a, b, local_length, scale, globalWorkSize0: globalWorkSize0, globalWorkSize1: globalWorkSize1, globalWorkSize2: globalWorkSize2, localWorkSize0: localWorkSize0, localWorkSize1: localWorkSize1, localWorkSize2: localWorkSize2, waitFor: waitFor));
}
public void Run(OpenCL.Net.CommandQueue commandQueue, OpenCL.Net.IMem <System.Single> a, OpenCL.Net.IMem <System.Single> b, int local_length, float scale, uint globalWorkSize0, uint globalWorkSize1, uint localWorkSize0 = 0, uint localWorkSize1 = 0, params OpenCL.Net.Event[] waitFor)
{
OpenCL.Net.Event ev = this.run(commandQueue, a, b, local_length, scale, globalWorkSize0: globalWorkSize0, globalWorkSize1: globalWorkSize1, localWorkSize0: localWorkSize0, localWorkSize1: localWorkSize1, waitFor: waitFor);
ev.Wait();
}
private void CrackImpl(byte[] plaintext_bytes, byte[] plaintext_lengths, byte[] target, out byte[] match)
{
Cl.ErrorCode error;
match = null;
//Create the required kernel (entry function)
Cl.Kernel kernel = Cl.Cl.CreateKernel(program, "md5", out error);
CheckErr(error, "Cl.CreateKernel");
int intPtrSize = 0;
intPtrSize = Marshal.SizeOf(typeof(IntPtr));
var plaintextBytesBuffer = Cl.Cl.CreateBuffer(_context, Cl.MemFlags.CopyHostPtr | Cl.MemFlags.ReadOnly, (IntPtr)plaintext_bytes.Length, plaintext_bytes, out error);
CheckErr(error, "Cl.CreateBuffer plaintext_bytes");
var plaintextLengthsBuffer = Cl.Cl.CreateBuffer(_context, Cl.MemFlags.CopyHostPtr | Cl.MemFlags.ReadOnly, (IntPtr)plaintext_lengths.Length, plaintext_lengths, out error);
CheckErr(error, "Cl.CreateBuffer plaintext_lengths");
var targetBuffer = Cl.Cl.CreateBuffer(_context, Cl.MemFlags.CopyHostPtr | Cl.MemFlags.ReadOnly, (IntPtr)KEY_LENGTH, target, out error);
CheckErr(error, "Cl.CreateBuffer target");
match = new byte[KEY_LENGTH];
var matchBuffer = Cl.Cl.CreateBuffer <byte>(_context, Cl.MemFlags.WriteOnly | Cl.MemFlags.CopyHostPtr, match, out error);
CheckErr(error, "Cl.CreateBuffer match");
//Pass the memory buffers to our kernel function
error = Cl.Cl.SetKernelArg(kernel, 0, (IntPtr)intPtrSize, plaintextBytesBuffer);
error |= Cl.Cl.SetKernelArg(kernel, 1, (IntPtr)intPtrSize, plaintextLengthsBuffer);
error |= Cl.Cl.SetKernelArg(kernel, 2, (IntPtr)intPtrSize, targetBuffer);
error |= Cl.Cl.SetKernelArg(kernel, 3, (IntPtr)intPtrSize, matchBuffer);
CheckErr(error, "Cl.SetKernelArg");
//Create a command queue, where all of the commands for execution will be added
Cl.CommandQueue cmdQueue = Cl.Cl.CreateCommandQueue(_context, _device, (Cl.CommandQueueProperties) 0, out error);
CheckErr(error, "Cl.CreateCommandQueue");
Cl.Event clevent;
IntPtr[] workGroupSizePtr = new IntPtr[] { (IntPtr)(plaintext_bytes.Length / KEY_LENGTH) };
//Execute our kernel (OpenCL code)
error = Cl.Cl.EnqueueNDRangeKernel(cmdQueue, kernel, 1, null, workGroupSizePtr, null, 0, null, out clevent);
CheckErr(error, "Cl.EnqueueNDRangeKernel");
//Wait for completion of all calculations on the GPU.
error = Cl.Cl.Finish(cmdQueue);
CheckErr(error, "Cl.Finish");
error = Cl.Cl.EnqueueReadBuffer(cmdQueue, matchBuffer, Cl.Bool.True, match, 0, null, out clevent);
CheckErr(error, "Cl.EnqueueReadBuffer");
//Clean up memory
Cl.Cl.ReleaseKernel(kernel);
Cl.Cl.ReleaseCommandQueue(cmdQueue);
Cl.Cl.ReleaseMemObject(plaintextBytesBuffer);
Cl.Cl.ReleaseMemObject(plaintextLengthsBuffer);
Cl.Cl.ReleaseMemObject(targetBuffer);
Cl.Cl.ReleaseMemObject(matchBuffer);
}
public static ErrorCode EnqueueReleaseGLObjects(CommandQueue queue, IMem[] glObjects, uint waitListCount, OpenCL.Net.Event[] waitList, out OpenCL.Net.Event outEvent)
{
return(clEnqueueReleaseGLObjects(queue, (uint)glObjects.Length, (from m in glObjects select(m as IHandleData).Handle).ToArray(), waitListCount, waitList, out outEvent));
}
private static extern ErrorCode clEnqueueReleaseGLObjects(CommandQueue queue,
uint num_objects,
[In][MarshalAs(UnmanagedType.LPArray)] IntPtr[] memObjects,
uint num_waitlist,
[In][MarshalAs(UnmanagedType.LPArray)] OpenCL.Net.Event[] waitList,
out Event ev);
public void Process(int[] inputArray, int inputImgWidth, int inputImgHeight, double threshold, out int[] outputArray)
{
Cl.ErrorCode error;
outputArray = null;
//Create the required kernel (entry function)
Cl.Kernel kernel = Cl.Cl.CreateKernel(program, "sobelEdgeDetect", out error);
CheckErr(error, "Cl.CreateKernel");
int intPtrSize = 0;
intPtrSize = Marshal.SizeOf(typeof(IntPtr));
//OpenCL memory buffer that will keep our image's byte[] data.
Cl.IMem inputImage2DBuffer;
Cl.ImageFormat clImageFormat = new Cl.ImageFormat(Cl.ChannelOrder.RGBA, Cl.ChannelType.Unsigned_Int8);
//Copy the raw bitmap data to an unmanaged byte[] array
//inputByteArray = new byte[inputImgBytesSize];
//Marshal.Copy(bitmapData.Scan0, inputByteArray, 0, inputImgBytesSize);
//Allocate OpenCL image memory buffer
inputImage2DBuffer = Cl.Cl.CreateImage2D(_context, Cl.MemFlags.CopyHostPtr | Cl.MemFlags.ReadOnly, clImageFormat,
(IntPtr)inputImgWidth, (IntPtr)inputImgHeight,
(IntPtr)0, inputArray, out error);
CheckErr(error, "Cl.CreateImage2D input");
//Unmanaged output image's raw RGBA byte[] array
outputArray = new int[inputArray.Length];
//Allocate OpenCL image memory buffer
Cl.IMem outputImage2DBuffer = Cl.Cl.CreateImage2D(_context, Cl.MemFlags.CopyHostPtr | Cl.MemFlags.WriteOnly, clImageFormat, (IntPtr)inputImgWidth,
(IntPtr)inputImgHeight, (IntPtr)0, outputArray, out error);
CheckErr(error, "Cl.CreateImage2D output");
//Pass the memory buffers to our kernel function
error = Cl.Cl.SetKernelArg(kernel, 0, (IntPtr)intPtrSize, inputImage2DBuffer);
error |= Cl.Cl.SetKernelArg(kernel, 1, (IntPtr)intPtrSize, outputImage2DBuffer);
error |= Cl.Cl.SetKernelArg(kernel, 2, (float)threshold / 250.0f);
CheckErr(error, "Cl.SetKernelArg");
//Create a command queue, where all of the commands for execution will be added
Cl.CommandQueue cmdQueue = Cl.Cl.CreateCommandQueue(_context, _device, (Cl.CommandQueueProperties) 0, out error);
CheckErr(error, "Cl.CreateCommandQueue");
Cl.Event clevent;
//Copy input image from the host to the GPU.
IntPtr[] originPtr = new IntPtr[] { (IntPtr)0, (IntPtr)0, (IntPtr)0 }; //x, y, z
IntPtr[] regionPtr = new IntPtr[] { (IntPtr)inputImgWidth, (IntPtr)inputImgHeight, (IntPtr)1 }; //x, y, z
IntPtr[] workGroupSizePtr = new IntPtr[] { (IntPtr)inputImgWidth, (IntPtr)inputImgHeight, (IntPtr)1 };
error = Cl.Cl.EnqueueWriteImage(cmdQueue, inputImage2DBuffer, Cl.Bool.True,
originPtr, regionPtr, (IntPtr)0, (IntPtr)0, inputArray, 0, null, out clevent);
CheckErr(error, "Cl.EnqueueWriteImage");
//Execute our kernel (OpenCL code)
error = Cl.Cl.EnqueueNDRangeKernel(cmdQueue, kernel, 2, null, workGroupSizePtr, null, 0, null, out clevent);
CheckErr(error, "Cl.EnqueueNDRangeKernel");
//Wait for completion of all calculations on the GPU.
error = Cl.Cl.Finish(cmdQueue);
CheckErr(error, "Cl.Finish");
//Read the processed image from GPU to raw RGBA data byte[] array
error = Cl.Cl.EnqueueReadImage(cmdQueue, outputImage2DBuffer, Cl.Bool.True, originPtr, regionPtr,
(IntPtr)0, (IntPtr)0, outputArray, 0, null, out clevent);
CheckErr(error, "Cl.clEnqueueReadImage");
//Clean up memory
Cl.Cl.ReleaseKernel(kernel);
Cl.Cl.ReleaseCommandQueue(cmdQueue);
Cl.Cl.ReleaseMemObject(inputImage2DBuffer);
Cl.Cl.ReleaseMemObject(outputImage2DBuffer);
}
