public static DisposableCollection <Device> PartitionByCounts(ClDeviceID device, int[] partitionSizes)
{
if (partitionSizes == null)
{
throw new ArgumentNullException(nameof(partitionSizes));
}
var propertiesList = new List <IntPtr>();
propertiesList.Add((IntPtr)PartitionProperty.PartitionByCounts);
foreach (int partitionSize in partitionSizes)
{
if (partitionSize < 0)
{
throw new ArgumentOutOfRangeException(nameof(partitionSizes), "Partition size cannot be negative.");
}
propertiesList.Add((IntPtr)partitionSize);
}
propertiesList.Add((IntPtr)PartitionProperty.PartitionByCountsListEnd);
propertiesList.Add(IntPtr.Zero);
IntPtr[] properties = propertiesList.ToArray();
return(CreateSubDevices(device, properties));
}
private static extern ErrorCode clGetKernelWorkGroupInfo(
KernelSafeHandle kernel,
ClDeviceID device,
int paramName,
UIntPtr paramValueSize,
IntPtr paramValue,
out UIntPtr paramValueSizeRet);
private static extern ErrorCode clGetProgramBuildInfo(
ProgramSafeHandle program,
ClDeviceID device,
int paramName,
UIntPtr paramValueSize,
IntPtr paramValue,
out UIntPtr paramValueSizeRet);
public static T GetProgramBuildInfo <T>(ProgramSafeHandle program, ClDeviceID device, ProgramBuildParameterInfo <T> parameter)
{
if (program == null)
{
throw new ArgumentNullException("program");
}
if (parameter == null)
{
throw new ArgumentNullException("parameter");
}
int?fixedSize = parameter.ParameterInfo.FixedSize;
#if DEBUG
bool verifyFixedSize = true;
#else
bool verifyFixedSize = false;
#endif
UIntPtr requiredSize;
if (fixedSize.HasValue && !verifyFixedSize)
{
requiredSize = (UIntPtr)fixedSize;
}
else
{
ErrorHandler.ThrowOnFailure(clGetProgramBuildInfo(program, device, parameter.ParameterInfo.Name, UIntPtr.Zero, IntPtr.Zero, out requiredSize));
}
if (verifyFixedSize && fixedSize.HasValue)
{
if (requiredSize.ToUInt64() != (ulong)fixedSize.Value)
{
throw new ArgumentException("The parameter definition includes a fixed size that does not match the required size according to the runtime.");
}
}
IntPtr memory = IntPtr.Zero;
try
{
memory = Marshal.AllocHGlobal((int)requiredSize.ToUInt32());
UIntPtr actualSize;
ErrorHandler.ThrowOnFailure(clGetProgramBuildInfo(program, device, parameter.ParameterInfo.Name, requiredSize, memory, out actualSize));
return(parameter.ParameterInfo.Deserialize(actualSize, memory));
}
finally
{
Marshal.FreeHGlobal(memory);
}
}
private static DisposableCollection<Device> CreateSubDevices(ClDeviceID device, IntPtr[] properties)
{
uint required;
ErrorHandler.ThrowOnFailure(clCreateSubDevices(device, properties, 0, null, out required));
ClDeviceID[] devices = new ClDeviceID[required];
uint actual;
ErrorHandler.ThrowOnFailure(clCreateSubDevices(device, properties, required, devices, out actual));
DisposableCollection<Device> result = new DisposableCollection<Device>(false);
for (int i = 0; i < actual; i++)
result.Add(new Device(devices[i], new DeviceSafeHandle(devices[i])));
return result;
}
public static ClDeviceID[] GetDeviceIDs(ClPlatformID platform, DeviceType deviceType)
{
uint required;
ErrorHandler.ThrowOnFailure(clGetDeviceIDs(platform, deviceType, 0, null, out required));
if (required == 0)
{
return(new ClDeviceID[0]);
}
ClDeviceID[] devices = new ClDeviceID[required];
uint actual;
ErrorHandler.ThrowOnFailure(clGetDeviceIDs(platform, deviceType, required, devices, out actual));
Array.Resize(ref devices, (int)actual);
return(devices);
}
private static DisposableCollection <Device> CreateSubDevices(ClDeviceID device, IntPtr[] properties)
{
uint required;
ErrorHandler.ThrowOnFailure(clCreateSubDevices(device, properties, 0, null, out required));
ClDeviceID[] devices = new ClDeviceID[required];
uint actual;
ErrorHandler.ThrowOnFailure(clCreateSubDevices(device, properties, required, devices, out actual));
var result = new DisposableCollection <Device>(false);
for (int i = 0; i < actual; i++)
{
result.Add(new Device(devices[i], new DeviceSafeHandle(devices[i])));
}
return(result);
}
public static DisposableCollection<Device> PartitionByCounts(ClDeviceID device, int[] partitionSizes)
{
if (partitionSizes == null)
throw new ArgumentNullException("partitionSizes");
List<IntPtr> propertiesList = new List<IntPtr>();
propertiesList.Add((IntPtr)PartitionProperty.PartitionByCounts);
foreach (int partitionSize in partitionSizes)
{
if (partitionSize < 0)
throw new ArgumentOutOfRangeException("partitionSizes", "Partition size cannot be negative.");
propertiesList.Add((IntPtr)partitionSize);
}
propertiesList.Add((IntPtr)PartitionProperty.PartitionByCountsListEnd);
propertiesList.Add(IntPtr.Zero);
IntPtr[] properties = propertiesList.ToArray();
return CreateSubDevices(device, properties);
}
public static DisposableCollection<Device> PartitionEqually(ClDeviceID device, int partitionSize)
{
IntPtr[] properties = { (IntPtr)PartitionProperty.PartitionEqually, (IntPtr)partitionSize, IntPtr.Zero };
return CreateSubDevices(device, properties);
}
private static extern ErrorCode clCreateSubDevices(
ClDeviceID device,
[In, MarshalAs(UnmanagedType.LPArray)] IntPtr[] properties,
uint numDevices,
[Out, MarshalAs(UnmanagedType.LPArray)] ClDeviceID[] devices,
out uint numDevicesRet);
private static extern ErrorCode clGetDeviceInfo(
ClDeviceID device,
int paramName,
UIntPtr paramValueSize,
IntPtr paramValue,
out UIntPtr paramValueSizeRet);
private static extern CommandQueueSafeHandle clCreateCommandQueue(
ContextSafeHandle context,
ClDeviceID device,
CommandQueueProperties properties,
out ErrorCode errorCode);
public static DisposableCollection <Device> PartitionByAffinityDomain(ClDeviceID device, AffinityDomain affinityDomain)
{
IntPtr[] properties = { (IntPtr)PartitionProperty.PartitionByAffinityDomain, (IntPtr)affinityDomain, IntPtr.Zero };
return(CreateSubDevices(device, properties));
}
public static DisposableCollection <Device> PartitionEqually(ClDeviceID device, int partitionSize)
{
IntPtr[] properties = { (IntPtr)PartitionProperty.PartitionEqually, (IntPtr)partitionSize, IntPtr.Zero };
return(CreateSubDevices(device, properties));
}
private static extern ErrorCode clCreateSubDevices(
ClDeviceID device,
[In, MarshalAs(UnmanagedType.LPArray)] IntPtr[] properties,
uint numDevices,
[Out, MarshalAs(UnmanagedType.LPArray)] ClDeviceID[] devices,
out uint numDevicesRet);
public static CommandQueueSafeHandle CreateCommandQueue(ContextSafeHandle context, ClDeviceID device, CommandQueueProperties properties)
{
ErrorCode errorCode;
CommandQueueSafeHandle result = clCreateCommandQueue(context, device, properties, out errorCode);
ErrorHandler.ThrowOnFailure(errorCode);
return(result);
}
public static DisposableCollection<Device> PartitionByAffinityDomain(ClDeviceID device, AffinityDomain affinityDomain)
{
IntPtr[] properties = { (IntPtr)PartitionProperty.PartitionByAffinityDomain, (IntPtr)affinityDomain, IntPtr.Zero };
return CreateSubDevices(device, properties);
}
public static ulong[] GetKernelWorkGroupInfo(KernelSafeHandle kernel, ClDeviceID device, KernelWorkGroupInfo kernelWorkGroupInfo)
{
if (kernel == null)
{
throw new ArgumentNullException("kernel");
}
int size = 0;
int arrayCt = 0;
switch (kernelWorkGroupInfo)
{
case KernelWorkGroupInfo.GlobalWorkSize:
size = UIntPtr.Size;
arrayCt = 3;
break;
case KernelWorkGroupInfo.WorkGroupSize:
size = UIntPtr.Size;
arrayCt = 1;
break;
case KernelWorkGroupInfo.CompileWorkGroupSize:
size = UIntPtr.Size;
arrayCt = 3;
break;
case KernelWorkGroupInfo.LocalMemorySize:
size = sizeof(ulong);
arrayCt = 1;
break;
case KernelWorkGroupInfo.PreferredWorkGroupSizeMultiple:
size = UIntPtr.Size;
arrayCt = 1;
break;
case KernelWorkGroupInfo.PrivateMemorySize:
size = sizeof(ulong);
arrayCt = 1;
break;
}
int fixedSize = size * arrayCt;
#if DEBUG
UIntPtr requiredSize;
ErrorHandler.ThrowOnFailure(clGetKernelWorkGroupInfo(kernel, device, (int)kernelWorkGroupInfo, UIntPtr.Zero, IntPtr.Zero, out requiredSize));
if (requiredSize.ToUInt64() != (ulong)fixedSize)
{
throw new ArgumentException("The parameter definition includes a fixed size that does not match the required size according to the runtime.");
}
#endif
IntPtr memory = IntPtr.Zero;
try
{
memory = Marshal.AllocHGlobal(fixedSize);
UIntPtr actualSize;
ErrorHandler.ThrowOnFailure(clGetKernelWorkGroupInfo(kernel, device, (int)kernelWorkGroupInfo, (UIntPtr)fixedSize, memory, out actualSize));
IntPtr[] array = new IntPtr[(int)((long)actualSize.ToUInt64() / IntPtr.Size)];
Marshal.Copy(memory, array, 0, array.Length);
ulong[] outArray = new ulong[arrayCt];
for (int i = 0; i < arrayCt; i++)
{
outArray[i] = (ulong)array[i];
}
return(outArray);
}
finally
{
Marshal.FreeHGlobal(memory);
}
}
