/// <summary>
/// Initializes handle
/// </summary>
/// <returns> whether or not the handle was intialized succesfully </returns>
public void Init()
{
Platform[] platforms = Cl.GetPlatformIDs(out _error);
CLException.CheckException(_error);
Console.WriteLine("Found " + platforms.Length + " platform(s)");
InfoBuffer platformNameBuffer = Cl.GetPlatformInfo(platforms[0], PlatformInfo.Name, out _error);
CLException.CheckException(_error);
Console.WriteLine(platformNameBuffer.ToString());
Device[] devices = Cl.GetDeviceIDs(platforms[0], DeviceType.Gpu, out _error);
CLException.CheckException(_error);
_device = devices[0];
InfoBuffer deviceNameBuffer = Cl.GetDeviceInfo(Device, DeviceInfo.Platform, out _error);
CLException.CheckException(_error);
Console.WriteLine(deviceNameBuffer.ToString());
_context = Cl.CreateContext(null, 1, new[] { devices[0] }, null, IntPtr.Zero, out _error);
CLException.CheckException(_error);
_queue = Cl.CreateCommandQueue(Context, Device, CommandQueueProperties.None, out _error);
CLException.CheckException(_error);
}
/// <summary>
/// Creates a kernel from a program
/// </summary>
/// <param name="kernelName">the name of the kernel</param>
public void CreateKernel(string kernelName)
{
Kernel kernel = Cl.CreateKernel(_program, kernelName, out _error);
CLException.CheckException(_error);
_kernels.Add(kernelName, kernel);
}
/// <summary>
/// Executes a 1D kernel
/// </summary>
/// <param name="kernel">Name of the kernel to execute</param>
/// <param name="globalWorkSize">Total Number of work items</param>
/// <param name="localWorkSize">Number of work items per local group</param>
public void ExecuteKernel1D(string kernel, int globalWorkSize, int localWorkSize)
{
Event e;
_error = Cl.EnqueueNDRangeKernel(_handle.Queue, _kernels[kernel], 1, null, new[] { new IntPtr(globalWorkSize) }, new[] { new IntPtr(localWorkSize) }, 0, null, out e);
CLException.CheckException(_error);
}
public void Dispose()
{
foreach (var kernel in _kernels.Values)
{
Cl.ReleaseKernel(kernel);
}
_error = Cl.ReleaseProgram(_program);
CLException.CheckException(_error);
}
/// <summary>
/// Creates all potential kernels in program
/// </summary>
public void CreateAllKernels()
{
Kernel[] kernels = Cl.CreateKernelsInProgram(_program, out _error);
CLException.CheckException(_error);
for (int i = 0; i < kernels.Length; i++)
{
InfoBuffer name = Cl.GetKernelInfo(kernels[i], KernelInfo.FunctionName, out _error);
_kernels.Add(name.ToString(), kernels[i]);
}
}
/// <summary>
/// Creates the program from source code
/// </summary>
/// <param name="sourceCode">source code</param>
public void CreateProgram(string[] sourceCode)
{
string source = "";
for (int i = 0; i < sourceCode.Length; i++)
{
source += sourceCode[i];
}
_program = Cl.CreateProgramWithSource(_handle.Context, 1,
new[] { source }, new[] { new IntPtr(source.Length) }, out _error);
CLException.CheckException(_error);
}
/// <summary>
/// Builds Program
/// </summary>
public void BuildProgram()
{
try
{
_error = Cl.BuildProgram(_program, 0, null, null, null, IntPtr.Zero);
CLException.CheckException(_error);
}
catch (CLException)
{
Console.WriteLine("Could not build program!");
InfoBuffer buildLog = Cl.GetProgramBuildInfo(_program, _handle.Device, ProgramBuildInfo.Log, out _error);
CLException.CheckException(_error);
Console.WriteLine("Build Log: " + buildLog.ToString());
}
}
/// <summary>
/// Writes an image to GPU memeory
/// </summary>
/// <param name="image">the image to write</param>
/// <param name="memFlags">the memory flags</param>
public void WriteImage(Bitmap image, MemFlags memFlags)
{
ErrorCode error;
_image = Cl.CreateImage2D(_handle.Context, memFlags, new OpenCL.Net.ImageFormat(ChannelOrder.RGBA, ChannelType.Unorm_Int8),
new IntPtr(image.Width), new IntPtr(image.Height), new IntPtr(0), new IntPtr(0), out error);
CLException.CheckException(error);
byte[] data = BmpToBytes(image);
IntPtr[] originArray = new IntPtr[] { new IntPtr(0), new IntPtr(0), new IntPtr(0) };
IntPtr[] sizeArray = new IntPtr[] { new IntPtr(image.Width), new IntPtr(image.Height), new IntPtr(1) };
Event e;
error = Cl.EnqueueWriteImage(_handle.Queue, _image, Bool.True,
originArray, sizeArray, new IntPtr(0), new IntPtr(0),
data, 0, null, out e);
CLException.CheckException(error);
}
/// <summary>
/// Sets an image as a kernel argument
/// </summary>
/// <param name="kernel">Name of the kernel to set the image paratmeter of</param>
/// <param name="argIndex">The argument index to set</param>
/// <param name="image">The image to set the argument of</param>
public void SetKernelArg(string kernel, uint argIndex, GPUImage image)
{
_error = Cl.SetKernelArg(_kernels[kernel], argIndex, image.ImageBufferHandle);
CLException.CheckException(_error);
}
/// <summary>
/// Sets the argument of the kernel's
/// </summary>
/// <param name="kernel">Name of the kernel to set the paramter of</param>
/// <param name="argIndex">Index of argument to set</param>
/// <param name="value">Value of argument</param>
public void SetKernelArg <T>(string kernel, uint argIndex, T value) where T : struct
{
_error = Cl.SetKernelArg(_kernels[kernel], argIndex, value);
CLException.CheckException(_error);
}
/// <summary>
/// Sets the argument of the kernel's
/// </summary>
/// <param name="kernel">Name of the kernel to set the paramter of</param>
/// <param name="argIndex">Index of argument to set</param>
/// <param name="value">Value of argument</param>
public void SetKernelArg <T>(string kernel, uint argIndex, GPUBuffer <T> buffer) where T : struct
{
_error = Cl.SetKernelArg(_kernels[kernel], argIndex, buffer.BufferHandle);
CLException.CheckException(_error);
}
/// <summary>
/// Creates a new GPU Buffer or predefined size
/// </summary>
/// <param name="handle">What GPU Instance to create it on</param>
/// <param name="flags">What Read/Write flags to use</param>
/// <param name="size">Size of memory of the buffer</param>
public GPUBuffer(GPUHandle handle, MemFlags flags, int size) : this(handle)
{
ErrorCode error;
_buffer = Cl.CreateBuffer <T>(handle.Context, flags, size, out error);
CLException.CheckException(error);
}
/// <summary>
/// Clean up memory on GPU
/// </summary>
public void Dispose()
{
_error = Cl.ReleaseCommandQueue(Queue);
CLException.CheckException(_error);
}
/// <summary>
/// Waits until the queue is empty
/// </summary>
public void WaitUntilDone()
{
_error = Cl.Finish(Queue);
CLException.CheckException(_error);
}
