internal Device(CLDeviceID id)
{
this.CLDeviceID = id;
this.PlatformID = GetDeviceInfo <CLPlatformID>(this, CLDeviceInfo.Platform);
this.AddressBits = GetDeviceInfo <Int32>(this, CLDeviceInfo.AddressBits);
this.Available = GetDeviceInfo <Boolean>(this, CLDeviceInfo.Available);
this.CompilerAvailable = GetDeviceInfo <Boolean>(this, CLDeviceInfo.CompilerAvailable);
this.DriverVersion = GetDeviceInfoString(this, CLDeviceInfo.DriverVersion);
this.EndianLittle = GetDeviceInfo <Boolean>(this, CLDeviceInfo.EndianLittle);
this.ErrorCorrectionSupport = GetDeviceInfo <Boolean>(this, CLDeviceInfo.ErrorCorrectionSupport);
this.ExecutionCapabilities = (DeviceExecCapabilities)GetDeviceInfo <ulong>(this, CLDeviceInfo.ExecutionCapabilities);
this.Extensions = GetDeviceInfoString(this, CLDeviceInfo.Extensions);
this.GlobalMemCacheLineSize = GetDeviceInfo <Int32>(this, CLDeviceInfo.GlobalMemCacheLineSize);
this.GlobalMemCacheSize = GetDeviceInfo <Int64>(this, CLDeviceInfo.GlobalMemCacheSize);
this.GlobalMemCacheType = (DeviceMemCacheType)GetDeviceInfo <uint>(this, CLDeviceInfo.GlobalMemCacheType);
this.GlobalMemSize = GetDeviceInfo <Int64>(this, CLDeviceInfo.GlobalMemSize);
this.Image2DMaxHeight = GetDeviceInfo <SizeT>(this, CLDeviceInfo.Image2DMaxHeight);
this.Image2DMaxWidth = GetDeviceInfo <SizeT>(this, CLDeviceInfo.Image2DMaxWidth);
this.Image3DMaxDepth = GetDeviceInfo <SizeT>(this, CLDeviceInfo.Image3DMaxDepth);
this.Image3DMaxHeight = GetDeviceInfo <SizeT>(this, CLDeviceInfo.Image3DMaxHeight);
this.Image3DMaxWidth = GetDeviceInfo <SizeT>(this, CLDeviceInfo.Image3DMaxWidth);
this.ImageSupport = GetDeviceInfo <Boolean>(this, CLDeviceInfo.ImageSupport);
this.LocalMemSize = GetDeviceInfo <Int64>(this, CLDeviceInfo.LocalMemSize);
this.LocalMemType = (DeviceLocalMemType)GetDeviceInfo <uint>(this, CLDeviceInfo.LocalMemType);
this.MaxClockFrequency = GetDeviceInfo <Int32>(this, CLDeviceInfo.MaxClockFrequency);
this.MaxComputeUnits = GetDeviceInfo <Int32>(this, CLDeviceInfo.MaxComputeUnits);
this.MaxConstantArgs = GetDeviceInfo <Int32>(this, CLDeviceInfo.MaxConstantArgs);
this.MaxConstantBufferSize = GetDeviceInfo <Int64>(this, CLDeviceInfo.MaxConstantBufferSize);
this.MaxMemAllocSize = GetDeviceInfo <Int64>(this, CLDeviceInfo.MaxMemAllocSize);
this.MaxParameterSize = GetDeviceInfo <SizeT>(this, CLDeviceInfo.MaxParameterSize);
this.MaxReadImageArgs = GetDeviceInfo <Int32>(this, CLDeviceInfo.MaxReadImageArgs);
this.MaxSamplers = GetDeviceInfo <Int32>(this, CLDeviceInfo.MaxSamplers);
this.MaxWorkGroupSize = GetDeviceInfo <SizeT>(this, CLDeviceInfo.MaxWorkGroupSize);
this.MaxWorkItemDimensions = GetDeviceInfo <Int32>(this, CLDeviceInfo.MaxWorkItemDimensions);
this.MaxWorkItemSizes = new SizeT[this.MaxWorkItemDimensions];
GCHandle bufferHandle = GCHandle.Alloc(this.MaxWorkItemSizes, GCHandleType.Pinned);
try
{
SizeT param_value_size_ret = SizeT.Zero;
OpenCLError.Validate(OpenCLDriver.clGetDeviceInfo(CLDeviceID, CLDeviceInfo.MaxWorkItemSizes, new SizeT(MaxWorkItemSizes.Length * IntPtr.Size), bufferHandle.AddrOfPinnedObject(), ref param_value_size_ret));
}
finally
{
bufferHandle.Free();
}
this.MaxWriteImageArgs = GetDeviceInfo <Int32>(this, CLDeviceInfo.MaxWriteImageArgs);
this.MemBaseAddrAlign = GetDeviceInfo <Int32>(this, CLDeviceInfo.MemBaseAddrAlign);
this.MinDataTypeAlignSize = GetDeviceInfo <Int32>(this, CLDeviceInfo.MinDataTypeAlignSize);
this.Name = GetDeviceInfoString(this, CLDeviceInfo.Name);
this.PreferredVectorWidthChar = GetDeviceInfo <Int32>(this, CLDeviceInfo.PreferredVectorWidthChar);
this.PreferredVectorWidthDouble = GetDeviceInfo <Int32>(this, CLDeviceInfo.PreferredVectorWidthDouble);
this.PreferredVectorWidthFloat = GetDeviceInfo <Int32>(this, CLDeviceInfo.PreferredVectorWidthFloat);
this.PreferredVectorWidthInt = GetDeviceInfo <Int32>(this, CLDeviceInfo.PreferredVectorWidthInt);
this.PreferredVectorWidthLong = GetDeviceInfo <Int32>(this, CLDeviceInfo.PreferredVectorWidthLong);
this.PreferredVectorWidthShort = GetDeviceInfo <Int32>(this, CLDeviceInfo.PreferredVectorWidthShort);
this.Profile = GetDeviceInfoString(this, CLDeviceInfo.Profile);
this.ProfilingTimerResolution = GetDeviceInfo <SizeT>(this, CLDeviceInfo.ProfilingTimerResolution);
this.QueueProperties = GetDeviceInfo <Int64>(this, CLDeviceInfo.QueueProperties);
this.SingleFPConfig = (DeviceFPConfig)GetDeviceInfo <ulong>(this, CLDeviceInfo.SingleFPConfig);
this.CLDeviceType = (CLDeviceType)GetDeviceInfo <ulong>(this, CLDeviceInfo.Type);
this.Vendor = GetDeviceInfoString(this, CLDeviceInfo.Vendor);
this.VendorID = GetDeviceInfo <Int32>(this, CLDeviceInfo.VendorID);
this.Version = GetDeviceInfoString(this, CLDeviceInfo.Version);
}
/// <summary>
/// Release OpenCL objects (final)
/// </summary>
internal static void Release()
{
try
{
CLError err;
// ADD YOUR CODE HERE
err = OpenCLDriver.clReleaseCommandQueue(comQ);
if (err != CLError.Success)
{
throw new Exception(err.ToString());
}
err = OpenCLDriver.clReleaseKernel(kernel_mult);
if (err != CLError.Success)
{
throw new Exception(err.ToString());
}
err = OpenCLDriver.clReleaseContext(ctx);
if (err != CLError.Success)
{
throw new Exception(err.ToString());
}
err = OpenCLDriver.clUnloadCompiler();
if (err != CLError.Success)
{
throw new Exception(err.ToString());
}
}
catch (Exception exc)
{
MessageBox.Show(exc.ToString());
}
}
internal static void ValidateBuild(CLProgram openclProgram, Device device, CLError error)
{
if (CLError.None != error)
{
SizeT bufferSize = SizeT.Zero;
OpenCLError.Validate(OpenCLDriver.clGetProgramBuildInfo(openclProgram, device.CLDeviceID, CLProgramBuildInfo.Log, SizeT.Zero, IntPtr.Zero, ref bufferSize));
byte[] buffer = new byte[(Int64)bufferSize];
GCHandle bufferHandle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
try
{
OpenCLError.Validate(OpenCLDriver.clGetProgramBuildInfo(openclProgram, device.CLDeviceID, CLProgramBuildInfo.Log, new SizeT(buffer.LongLength), bufferHandle.AddrOfPinnedObject(), ref bufferSize));
Int32 count = Array.IndexOf <byte>(buffer, 0);
throw new OpenCLBuildError(error, System.Text.Encoding.ASCII.GetString(buffer, 0, count < 0 ? buffer.Length : count).Trim());
}
finally
{
bufferHandle.Free();
}
}
}
internal override void SetAsKernelArgument(CLKernel kernel, int index)
{
var clMem = new CLMem
{
Value = openCLSampler.Value
};
OpenCLError.Validate(OpenCLDriver.clSetKernelArg(kernel, index, new SizeT(IntPtr.Size), ref clMem));
}
public static Context Share(IntPtr openclContext)
{
SizeT devicesSize = SizeT.Zero;
CLContext clContext = new CLContext {
Value = openclContext
};
OpenCLError.Validate(OpenCLDriver.clGetContextInfo(clContext, CLContextInfo.Devices, SizeT.Zero, IntPtr.Zero, ref devicesSize));
CLDeviceID[] devices = new CLDeviceID[((Int64)(devicesSize)) / IntPtr.Size];
GCHandle devicesHandle = GCHandle.Alloc(devices, GCHandleType.Pinned);
try
{
OpenCLError.Validate(OpenCLDriver.clGetContextInfo(clContext, CLContextInfo.Devices, devicesSize, devicesHandle.AddrOfPinnedObject(), ref devicesSize));
Dictionary <CLPlatformID, CLPlatformID> platformsDictionary = new Dictionary <CLPlatformID, CLPlatformID>();
CLPlatformID[] platforms = null;
foreach (CLDeviceID device in devices)
{
SizeT platformsSize = SizeT.Zero;
OpenCLError.Validate(OpenCLDriver.clGetDeviceInfo(device, CLDeviceInfo.Platform, SizeT.Zero, platforms, ref platformsSize));
platforms = new CLPlatformID[((Int64)(platformsSize)) / IntPtr.Size];
OpenCLError.Validate(OpenCLDriver.clGetDeviceInfo(device, CLDeviceInfo.Platform, platformsSize, platforms, ref platformsSize));
foreach (CLPlatformID platform in platforms)
{
if (!platformsDictionary.ContainsKey(platform))
{
platformsDictionary.Add(platform, platform);
}
}
}
platforms = new CLPlatformID[platformsDictionary.Count];
Int32 index = 0;
foreach (var platform in platformsDictionary.Keys)
{
platforms[index++] = platform;
}
return(new Context(clContext, new Platforms(platforms), new Devices(devices)));
}
finally
{
devicesHandle.Free();
}
}
public static CommandQueue Create(Context context, Device device, CommandQueueProperties commandQueueProperties)
{
CLError error = CLError.None;
CLCommandQueue openclCommandQueue = OpenCLDriver.clCreateCommandQueue(context.CLContext, device.CLDeviceID, (ManOCL.Internal.OpenCL.CLCommandQueueProperties)commandQueueProperties, ref error);
OpenCLError.Validate(error);
return(new CommandQueue(openclCommandQueue, context, device, commandQueueProperties));
}
public static Context Create(Platforms platforms, Devices devices)
{
CLError error = CLError.None;
// TODO: Add parameter pfn_notify (logging function)
CLContext openclContext = OpenCLDriver.clCreateContext(GetContextProperties(platforms), devices.Count, devices.OpenCLDeviceArray, null, IntPtr.Zero, ref error);
OpenCLError.Validate(error);
return(new Context(openclContext, platforms, devices));
}
private static Byte[] GetDeviceInfoBuffer(Device device, CLDeviceInfo deviceInfo)
{
SizeT bufferSize = SizeT.Zero;
OpenCLError.Validate(OpenCLDriver.clGetDeviceInfo(device.CLDeviceID, deviceInfo, SizeT.Zero, IntPtr.Zero, ref bufferSize));
Byte[] buffer = new Byte[(Int64)bufferSize];
OpenCLError.Validate(OpenCLDriver.clGetDeviceInfo(device.CLDeviceID, deviceInfo, bufferSize, buffer, ref bufferSize));
return(buffer);
}
public static Kernel Create(String name, CommandQueue commandQueue, Program sources, params Argument[] arguments)
{
CLError error = CLError.None;
CLKernel openclKernel = OpenCLDriver.clCreateKernel(sources.CLProgram, name, ref error);
Kernel result = new Kernel(openclKernel, sources, commandQueue, name.Length + 1);
result.InitializeArguments(arguments);
return(result);
}
public static Program Create(String[] sources, Context context, Devices devices, String buildOptions)
{
CLError error = CLError.None;
CLProgram openclProgram = OpenCLDriver.clCreateProgramWithSource(context.CLContext, sources.Length, sources, GetLengths(sources), ref error);
OpenCLError.Validate(error);
OpenCLBuildError.ValidateBuild(openclProgram, devices[0], OpenCLDriver.clBuildProgram(openclProgram, devices.Count, devices.OpenCLDeviceArray, buildOptions, null, IntPtr.Zero));
return(new Program(openclProgram, sources, context, devices, buildOptions));
}
public static Platforms Create()
{
Int32 platformsCount = 0;
OpenCLError.Validate(OpenCLDriver.clGetPlatformIDs(0, null, ref platformsCount));
CLPlatformID[] platforms = new CLPlatformID[platformsCount];
OpenCLError.Validate(OpenCLDriver.clGetPlatformIDs(platformsCount, platforms, ref platformsCount));
return(new Platforms(platforms));
}
public static DeviceSampler Create(Boolean normalizedCoords, AddressingMode addressingMode, FilterMode filterMode, Context context)
{
CLError error = new CLError();
CLSampler sampler = OpenCLDriver.clCreateSampler(context.CLContext, normalizedCoords ? CLBool.True : CLBool.False, (CLAddressingMode)addressingMode, (CLFilterMode)filterMode, ref error);
OpenCLError.Validate(error);
return(new DeviceSampler()
{
openCLSampler = sampler
});
}
internal override void SetAsKernelArgument(CLKernel kernel, int index)
{
GCHandle handle = GCHandle.Alloc(Value, GCHandleType.Pinned);
try
{
OpenCLError.Validate(OpenCLDriver.clSetKernelArg(kernel, index, new SizeT(Marshal.SizeOf(typeof(T))), handle.AddrOfPinnedObject()));
}
finally
{
handle.Free();
}
}
public static void CreateAsync <T>(CreateCallback <T> createCallback, T userData, String[] sources, Devices devices, Context context, String buildOptions)
{
CLError error = CLError.None;
CLProgram openclProgram = OpenCLDriver.clCreateProgramWithSource(context.CLContext, sources.Length, sources, GetLengths(sources), ref error);
OpenCLError.Validate(error);
Program program = new Program(openclProgram, sources, context, devices, buildOptions);
program.AsyncHelperObject = new AsyncHelper <T>(program, createCallback, userData);
OpenCLError.Validate(OpenCLDriver.clBuildProgram(openclProgram, devices.Count, devices.OpenCLDeviceArray, buildOptions, program.AsyncCallback, IntPtr.Zero));
}
public static Devices Create(CLDeviceType deviceType, Platform platform)
{
Int32 deviceCount = 0;
CLPlatformID pfm = platform == null ? new CLPlatformID() : platform.CLPlatformID;
OpenCLError.Validate(OpenCLDriver.clGetDeviceIDs(pfm, (ManOCL.Internal.OpenCL.CLDeviceType)deviceType, 0, null, ref deviceCount));
CLDeviceID[] deviceIds = new CLDeviceID[deviceCount];
OpenCLError.Validate(OpenCLDriver.clGetDeviceIDs(pfm, (ManOCL.Internal.OpenCL.CLDeviceType)deviceType, deviceCount, deviceIds, ref deviceCount));
return(new Devices(deviceIds));
}
protected virtual void Dispose(Boolean disposing)
{
if (!disposed)
{
disposed = true;
// if (disposing)
// {
// No managed resources to dispose
// }
OpenCLDriver.clReleaseEvent(CLEvent);
}
}
internal Event ExecuteInternal(SizeT[] globalWorkSize, SizeT[] localWorkSize, Events eventWaitList, SizeT[] globalWorkOffset)
{
if (localWorkSize == null || globalWorkSize.Length == localWorkSize.Length)
{
CLEvent e = new CLEvent();
OpenCLError.Validate(OpenCLDriver.clEnqueueNDRangeKernel(CommandQueue.CLCommandQueue, CLKernel, globalWorkSize.Length, globalWorkOffset, globalWorkSize, localWorkSize, eventWaitList.Count, eventWaitList.OpenCLEventArray, ref e));
return(new Event(e));
}
else
{
throw new ArgumentException(Resources.LocalWorkSize_and_GlobalWorkSize_dimensions_do_not_agree);
}
}
private static Int64 GetInfo(Event e, CLProfilingInfo info)
{
Byte[] bytes = new Byte[8];
SizeT paramValueSizeRet = SizeT.Zero;
GCHandle bytesHandle = GCHandle.Alloc(bytes, GCHandleType.Pinned);
{
OpenCLError.Validate(OpenCLDriver.clGetEventProfilingInfo(e.CLEvent, info, new SizeT(bytes.LongLength), bytesHandle.AddrOfPinnedObject(), ref paramValueSizeRet));
}
bytesHandle.Free();
return(BitConverter.ToInt64(bytes, 0));
}
/// <summary>
/// Setup OpenCL
/// </summary>
internal static void Setup()
{
try
{
// ADD YOUR CODE HERE
CLError err;
uint num_entries = 0;// get platform
CLPlatformID[] platforms = new CLPlatformID[5];
err = OpenCLDriver.clGetPlatformIDs(5, platforms, ref num_entries);
if (num_entries == 0)
{
throw new Exception("No Platform Entries found!");
}
//get device ID
CLDeviceID[] devices = new CLDeviceID[1];
err = OpenCLDriver.clGetDeviceIDs(platforms[0], CLDeviceType.GPU, 1, devices, ref num_entries);
// create context
ctx = OpenCLDriver.clCreateContext(null, 1, devices, null, IntPtr.Zero, ref err);
if (err != CLError.Success)
{
throw new Exception(err.ToString());
}
// create command queue
comQ = OpenCLDriver.clCreateCommandQueue(ctx, devices[0], 0, ref err);
if (err != CLError.Success)
{
throw new Exception(err.ToString());
}
// Compile Program
string[] progString = new string[1];
progString[0] = File.ReadAllText("..\\..\\prog.cl");
program = OpenCLDriver.clCreateProgramWithSource(ctx, 1, progString, null, ref err);
err = OpenCLDriver.clBuildProgram(program, 1, devices, "", null, IntPtr.Zero);
//create kernel
kernel_mult = OpenCLDriver.clCreateKernel(program, "multiply", ref err);
}
catch (Exception exc)
{
MessageBox.Show(exc.ToString());
}
}
public static IntPtr ShareForMac(IntPtr cglShareGroup)
{
CLError error = CLError.None;
IntPtr[] properties =
{
new IntPtr(0x10000000), // CL_CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE
cglShareGroup,
new IntPtr(0)
};
// TODO: Add parameter pfn_notify (logging function)
CLContext openclContext = OpenCLDriver.clCreateContext(properties, 0, null, null, IntPtr.Zero, ref error);
OpenCLError.Validate(error);
return(openclContext.Value);
}
internal static Kernels CreateInternal(CommandQueue commandQueue, Program program, Int32 kernelsCount, Int32 kernelInfoBufferSize)
{
Validate(commandQueue, program);
Int32 numKernelsRet = 0;
CLKernel[] openclKernels = new CLKernel[kernelsCount];
OpenCLError.Validate(OpenCLDriver.clCreateKernelsInProgram(program.CLProgram, openclKernels.Length, openclKernels, ref numKernelsRet));
Kernel[] result = new Kernel[numKernelsRet];
for (int i = 0; i < numKernelsRet; i++)
{
result[i] = new Kernel(openclKernels[i], program, commandQueue, kernelInfoBufferSize);
}
return(new Kernels(result));
}
private static String GetPlatformInfo(Platform platform, CLPlatformInfo platformInfo)
{
if (platform.CLPlatformID.Value == IntPtr.Zero)
{
return("None");
}
else
{
SizeT buffer_size = SizeT.Zero;
OpenCLError.Validate(OpenCLDriver.clGetPlatformInfo(platform.CLPlatformID, platformInfo, SizeT.Zero, null, ref buffer_size));
Byte[] buffer = new Byte[(Int64)buffer_size];
OpenCLError.Validate(OpenCLDriver.clGetPlatformInfo(platform.CLPlatformID, platformInfo, buffer_size, buffer, ref buffer_size));
Int32 count = Array.IndexOf <byte>(buffer, 0);
return(System.Text.Encoding.ASCII.GetString(buffer, 0, count < 0 ? buffer.Length : count));
}
}
private static Byte[] GetKernelInfoBuffer(CLKernel openclKernel, CLKernelInfo kernelInfo, Int32 kernelInfoBufferSize)
{
SizeT bufferSize = SizeT.Zero;
Byte[] buffer = new Byte[kernelInfoBufferSize];
GCHandle bufferHandle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
IntPtr bufferPtr = bufferHandle.AddrOfPinnedObject();
try
{
OpenCLError.Validate(OpenCLDriver.clGetKernelInfo(openclKernel, kernelInfo, new SizeT(buffer.Length), bufferPtr, ref bufferSize));
}
finally
{
bufferHandle.Free();
}
Array.Resize(ref buffer, (int)bufferSize);
return(buffer);
}
/// <summary>
/// Multiply an array by a constant value
/// </summary>
internal static void Multiply()
{
try
{
CLError err = new CLError();
//Allocate memory
float[] arr = new float[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
GCHandle arrGC = GCHandle.Alloc(arr, GCHandleType.Pinned);
CLMem bufferFilter = OpenCLDriver.clCreateBuffer(ctx, CLMemFlags.ReadWrite | CLMemFlags.CopyHostPtr, new SizeT(arr.Length * sizeof(float)), arrGC.AddrOfPinnedObject(), ref err);
//set parameters
unsafe
{
OpenCLDriver.clSetKernelArg(kernel_mult, 0, new SizeT(sizeof(CLMem)), ref bufferFilter);
}
//Define grid & execute
err = OpenCLDriver.clFinish(comQ);
SizeT[] localws = { 5, 1 };
SizeT[] globalws = { 10, 1 };
CLEvent eventObj = new CLEvent();
err = OpenCLDriver.clEnqueueNDRangeKernel(comQ, kernel_mult, 2, null,
globalws, localws, 0, null, ref eventObj);
CLEvent[] eventObjs = new CLEvent[1];
eventObjs[0] = eventObj;
OpenCLDriver.clWaitForEvents(1, eventObjs);
// read buffer
err = OpenCLDriver.clEnqueueReadBuffer(comQ, bufferFilter, CLBool.True, 0,
10 * sizeof(float), arrGC.AddrOfPinnedObject(), 0, null, ref eventObj);
TableForm.ShowTableStatic(arr, "OpenCL Test");
}
catch (Exception exc)
{
MessageBox.Show(exc.ToString());
}
}
internal override void SetAsKernelArgument(CLKernel kernel, int index)
{
OpenCLError.Validate(OpenCLDriver.clSetKernelArg(kernel, index, new SizeT(IntPtr.Size), ref openCLMem));
}
public static Context ShareWithCGL(IntPtr cglShareGroup)
{
IntPtr[] properties =
{
new IntPtr(0x10000000), // CL_CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE
cglShareGroup,
new IntPtr(0)
};
CLError error = CLError.None;
// TODO: Add parameter pfn_notify (logging function)
CLContext openclContext = OpenCLDriver.clCreateContext(properties, 0, null, null, IntPtr.Zero, ref error);
OpenCLError.Validate(error);
SizeT devicesSize = SizeT.Zero;
OpenCLError.Validate(OpenCLDriver.clGetContextInfo(openclContext, CLContextInfo.Devices, SizeT.Zero, IntPtr.Zero, ref devicesSize));
CLDeviceID[] devices = new CLDeviceID[((Int64)(devicesSize)) / IntPtr.Size];
GCHandle devicesHandle = GCHandle.Alloc(devices, GCHandleType.Pinned);
try
{
OpenCLError.Validate(OpenCLDriver.clGetContextInfo(openclContext, CLContextInfo.Devices, devicesSize, devicesHandle.AddrOfPinnedObject(), ref devicesSize));
Dictionary <CLPlatformID, CLPlatformID> platformsDictionary = new Dictionary <CLPlatformID, CLPlatformID>();
CLPlatformID[] platforms = null;
foreach (CLDeviceID device in devices)
{
SizeT platformsSize = SizeT.Zero;
OpenCLError.Validate(OpenCLDriver.clGetDeviceInfo(device, CLDeviceInfo.Platform, SizeT.Zero, platforms, ref platformsSize));
platforms = new CLPlatformID[((Int64)(platformsSize)) / IntPtr.Size];
OpenCLError.Validate(OpenCLDriver.clGetDeviceInfo(device, CLDeviceInfo.Platform, platformsSize, platforms, ref platformsSize));
foreach (CLPlatformID platform in platforms)
{
if (!platformsDictionary.ContainsKey(platform))
{
platformsDictionary.Add(platform, platform);
}
}
}
platforms = new CLPlatformID[platformsDictionary.Count];
Int32 index = 0;
foreach (var platform in platformsDictionary.Keys)
{
platforms[index++] = platform;
}
return(new Context(openclContext, new Platforms(platforms), new Devices(devices)));
}
finally
{
devicesHandle.Free();
}
}
internal override void SetAsKernelArgument(CLKernel kernel, Int32 index)
{
OpenCLError.Validate(OpenCLDriver.clSetKernelArg(kernel, index, new SizeT(IntPtr.Size), memObjects));
}
/// <summary>
/// Get platform and device info
/// </summary>
internal static void GetInfo()
{
try
{
uint num_entries = 0;
uint num_entries_devices = 0;
// get device
CLPlatformID[] platforms = new CLPlatformID[5];
CLError err = OpenCLDriver.clGetPlatformIDs(5, platforms, ref num_entries);
if (err != CLError.Success)
{
throw new Exception(err.ToString());
}
if (num_entries == 0)
{
throw new Exception("No Platform Entries found!");
}
// get platform properties
byte[] buffer = new byte[1000];
GCHandle bufferGC = GCHandle.Alloc(buffer, GCHandleType.Pinned);
SizeT buffSize, buffSizeOut = new SizeT();
for (int i = 0; i < num_entries; i++)
{
buffSize = new CASS.Types.SizeT(1000);
err = OpenCLDriver.clGetPlatformInfo(platforms[i], CLPlatformInfo.Name, buffSize,
bufferGC.AddrOfPinnedObject(), ref buffSizeOut);
if (err != CLError.Success)
{
throw new Exception(err.ToString());
}
MessageBox.Show("Platform: " + i + "\n" + System.Text.Encoding.ASCII.GetString(buffer));
CLDeviceID[] devices = new CLDeviceID[2];
err = OpenCLDriver.clGetDeviceIDs(platforms[i], CLDeviceType.All, 2, devices, ref num_entries_devices);
if (err != CLError.Success)
{
throw new Exception(err.ToString());
}
string result = "";
err = OpenCLDriver.clGetDeviceInfo(devices[0], CLDeviceInfo.Vendor, buffSize,
bufferGC.AddrOfPinnedObject(), ref buffSizeOut);
result += CLDeviceInfo.Vendor.ToString() + ": " +
Encoding.ASCII.GetString(buffer, 0, buffSizeOut - 1) + "\n";
buffSize = new CASS.Types.SizeT(1000);
err = OpenCLDriver.clGetDeviceInfo(devices[0], CLDeviceInfo.Name, buffSize,
bufferGC.AddrOfPinnedObject(), ref buffSizeOut);
result += CLDeviceInfo.Name.ToString() + ": " +
Encoding.ASCII.GetString(buffer, 0, buffSizeOut - 1) + "\n";
int[] workDim = new int[1];
bufferGC = GCHandle.Alloc(workDim, GCHandleType.Pinned);
buffSize = new CASS.Types.SizeT(sizeof(int));
err = OpenCLDriver.clGetDeviceInfo(devices[0], CLDeviceInfo.MaxComputeUnits, buffSize,
bufferGC.AddrOfPinnedObject(), ref buffSizeOut);
result += CLDeviceInfo.MaxComputeUnits.ToString() + ": " + workDim[0] + "\n";
err = OpenCLDriver.clGetDeviceInfo(devices[0], CLDeviceInfo.MaxWorkItemDimensions,
workDim.Length * sizeof(int), bufferGC.AddrOfPinnedObject(), ref buffSizeOut);
result += CLDeviceInfo.MaxWorkItemDimensions.ToString() + ": " + workDim[0] + "\n";
SizeT[] sizeWI = new SizeT[workDim[0]];
bufferGC = GCHandle.Alloc(sizeWI, GCHandleType.Pinned);
err = OpenCLDriver.clGetDeviceInfo(devices[0], CLDeviceInfo.MaxWorkItemSizes, sizeWI.Length *
sizeof(int), bufferGC.AddrOfPinnedObject(), ref buffSizeOut);
result += CLDeviceInfo.MaxWorkItemSizes.ToString() + ": " +
sizeWI[0] + "x" + sizeWI[1] + "x" + sizeWI[2] + "\n";
MessageBox.Show(result, "Device");
}
}
catch (Exception exc)
{
MessageBox.Show(exc.ToString());
}
}
public void Finish()
{
OpenCLError.Validate(OpenCLDriver.clFinish(CLCommandQueue));
}
