internal CommandQueue(CLCommandQueue openclCommandQueue, Context context, Device device, CommandQueueProperties commandQueueProperties)
{
this.Device = device;
this.Context = context;
this.CLCommandQueue = openclCommandQueue;
this.CLCommandQueueProperties = commandQueueProperties;
}
public Environment(string platformWildCard, DeviceType deviceType = DeviceType.Default,
CommandQueueProperties commandQueueProperties = CommandQueueProperties.None)
{
ErrorCode error;
Context = Cl.CreateContext(platformWildCard, deviceType, out error);
error.Check();
var deviceInfoBuffer = Cl.GetContextInfo(Context, ContextInfo.Devices, out error);
error.Check();
Devices = deviceInfoBuffer.CastToArray <Device>(deviceInfoBuffer.Size / Marshal.SizeOf(typeof(IntPtr)));
List <DeviceType> list1 = new List <DeviceType>();
foreach (var d in Devices)
{
list1.Add(Cl.GetDeviceInfo(d, DeviceInfo.Type, out error).CastTo <DeviceType>());
error.Check();
}
DeviceTypes = list1.ToArray();
List <CommandQueue> list = new List <CommandQueue>();
foreach (var d in Devices)
{
list.Add(Cl.CreateCommandQueue(Context, d, commandQueueProperties, out error));
error.Check();
}
CommandQueues = list.ToArray();
}
public CommandQueue CreateCommandQueue(Device device, CommandQueueProperties properties)
{
int errcode;
IntPtr command_queue = Native.clCreateCommandQueue(_handle, device.Handle, properties, out errcode);
OpenCLException.Check(errcode);
return(new CommandQueue(this, device, command_queue));
}
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 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 CommandQueue CreateCommandQueue(Device device, CommandQueueProperties properties)
{
if (device == null)
{
throw new ArgumentNullException("device");
}
CommandQueueSafeHandle handle = UnsafeNativeMethods.CreateCommandQueue(this.Handle, device.ID, properties);
return(new CommandQueue(handle, this, device));
}
public CommandQueue CreateCommandQueue(Device device, CommandQueueProperties properties)
{
IntPtr commandQueueID;
ErrorCode result;
commandQueueID = (IntPtr)OpenCL.CreateCommandQueue(ContextID, device.DeviceID, (ulong)properties, out result);
if (result != ErrorCode.SUCCESS)
{
throw new OpenCLException("CreateCommandQueue failed with error code " + result, result);
}
return(new CommandQueue(this, device, commandQueueID));
}
public IntPtr clCreateCommandQueue(IntPtr context, IntPtr device, CommandQueueProperties properties,
out OpenClErrorCode errorCode)
{
errorCode = clCreateCommandQueueErrorCode ?? OpenClErrorCode.Success;
var id = clCreateCommandQueueResult ?? new IntPtr(1);
if (errorCode == OpenClErrorCode.Success)
{
FakeCommandQueues[id] = new FakeCommandQueue(context, device, properties);
}
return(id);
}
public CommandQueue(Context context, Device device, CommandQueueProperties properties) : this()
{
if (context == Context.Null)
{
throw new ArgumentNullException("context");
}
unsafe
{
int error = 0;
Handle = Cl.CreateCommandQueue(context.Handle, device.Handle, (ulong)properties, &error);
ClHelper.GetError(error);
}
}
public FakeCommandQueue(IntPtr contextId, IntPtr deviceId, CommandQueueProperties props)
{
ContextId = contextId;
DeviceId = deviceId;
Properties = props;
Infos = new InfoLookup <CommandQueueInfoParameter>
{
{ CommandQueueInfoParameter.Context, contextId },
{ CommandQueueInfoParameter.Device, deviceId },
{ CommandQueueInfoParameter.Properties, Properties },
{ CommandQueueInfoParameter.ReferenceCount, (uint)1 }
};
}
/// <summary>
/// Creates a <see cref="CommandQueue"/> on a specific <see cref="Device"/>.
/// </summary>
/// <param name="device">Is a device associated with this Context. If null, the first available Device will be used.</param>
/// <param name="properties">A list of properties for the CommandQueue.</param>
/// <returns>A new <see cref="CommandQueue"/>.</returns>
public CommandQueue CreateCommandQueue(Device device = null, CommandQueueProperties properties = CommandQueueProperties.None)
{
if (device == null)
{
device = Devices[0];
}
IntPtr commandQueueHandle = clCreateCommandQueue(Handle, device.Handle, properties, out error);
if (error != ErrorCode.Success)
{
return(null);
}
return(new CommandQueue(commandQueueHandle, this, device));
}
public Environment(string platformWildCard, DeviceType deviceType = DeviceType.Default,
CommandQueueProperties commandQueueProperties = CommandQueueProperties.None)
{
ErrorCode error;
Context = Cl.CreateContext(platformWildCard, deviceType, out error);
error.Check();
var deviceInfoBuffer = Cl.GetContextInfo(Context, ContextInfo.Devices, out error);
error.Check();
Devices = deviceInfoBuffer.CastToArray <Device>(deviceInfoBuffer.Size / Marshal.SizeOf(typeof(IntPtr)));
DeviceTypes = (from d in Devices select Cl.GetDeviceInfo(d, DeviceInfo.Type, out error).CastTo <DeviceType>()).ToArray();
error.Check();
CommandQueues = (from d in Devices select Cl.CreateCommandQueue(Context, d, commandQueueProperties, out error)).ToArray();
error.Check();
}
internal CommandQueue(Context context, Device device, bool enableProfiling, bool enableOutOfOrderExecutionMode, ICommandQueueApi commandQueueApi)
{
Context = context ?? throw new ArgumentNullException(nameof(context));
Device = device ?? throw new ArgumentNullException(nameof(device));
_commandQueueApi = commandQueueApi ?? throw new ArgumentNullException(nameof(commandQueueApi));
CommandQueueProperties props = 0b0;
if (enableProfiling)
{
props |= CommandQueueProperties.ProfilingEnable;
}
if (enableOutOfOrderExecutionMode)
{
props |= CommandQueueProperties.OutOfOrderExecModeEnable;
}
var id = _commandQueueApi.clCreateCommandQueue(context.Id, device.Id, props, out var error);
error.ThrowOnError();
Id = id;
}
public void SetProperty(CommandQueueProperties properties, bool enable, out CommandQueueProperties oldProperties)
{
ErrorCode result;
ulong returnedProperties = 0;
#pragma warning disable 618
result = (ErrorCode)OpenCL.SetCommandQueueProperty( CommandQueueID,
(ulong)properties,
enable,
out returnedProperties );
if( result!=ErrorCode.SUCCESS )
throw new OpenCLException( "SetCommandQueueProperty failed with error code "+result , result);
oldProperties = (CommandQueueProperties)returnedProperties;
#pragma warning restore 618
}
internal static extern IntPtr clCreateCommandQueue(IntPtr context, IntPtr device, [MarshalAs(UnmanagedType.U8)] CommandQueueProperties properties, out ErrorCode error);
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);
}
private static extern CommandQueueSafeHandle clCreateCommandQueue(
ContextSafeHandle context,
ClDeviceID device,
CommandQueueProperties properties,
out ErrorCode errorCode);
public static CommandQueue Create(Device device, CommandQueueProperties commandQueueProperties)
{
return Create(Context.Default, device, commandQueueProperties);
}
private extern static IntPtr clCreateCommandQueue(
IntPtr context,
IntPtr device,
CommandQueueProperties properties,
out ErrorCode errcode_ret);
public CommandQueue CreateCommandQueue( Device device, CommandQueueProperties properties )
{
IntPtr commandQueueID;
ErrorCode result;
commandQueueID = (IntPtr)OpenCL.CreateCommandQueue( ContextID, device.DeviceID, (ulong)properties, out result );
if( result!=ErrorCode.SUCCESS )
throw new OpenCLException( "CreateCommandQueue failed with error code "+result, result);
return new CommandQueue( this, device, commandQueueID );
}
public static CommandQueue Create(Device device, CommandQueueProperties commandQueueProperties)
{
return(Create(Context.Default, device, commandQueueProperties));
}
public static extern IntPtr CreateCommandQueue(IntPtr context, IntPtr device,
[MarshalAs(UnmanagedType.U8)] CommandQueueProperties properties,
[Out][MarshalAs(UnmanagedType.I4)] out ErrorCode error);
public static Error clSetCommandQueueProperty(OpenCLCommandQueue command_queue, CommandQueueProperties properties, Boolean enable, CommandQueueProperties old_properties)
{
Console.WriteLine("Calling Error clSetCommandQueueProperty(OpenCLCommandQueue command_queue, CommandQueueProperties properties, Boolean enable, CommandQueueProperties old_properties)");
return default(Error);
}
internal CommandQueue(CLCommandQueue openclCommandQueue, Context context, Device device, CommandQueueProperties commandQueueProperties)
{
this.Device = device;
this.Context = context;
this.CLCommandQueue = openclCommandQueue;
this.CLCommandQueueProperties = commandQueueProperties;
}
public static extern Error clSetCommandQueueProperty(OpenCLCommandQueue command_queue, CommandQueueProperties properties, Boolean enable, CommandQueueProperties old_properties);
public extern static IntPtr clCreateCommandQueue(
IntPtr context,
IntPtr device,
CommandQueueProperties properties,
out int errcode_ret);
internal static extern ErrorCode clSetCommandQueueProperty(IntPtr commandQueue, [MarshalAs(UnmanagedType.U8)] CommandQueueProperties properties, bool enable, [MarshalAs(UnmanagedType.U8)] out CommandQueueProperties oldProperties);
public CommandQueue CreateCommandQueue(Device device, CommandQueueProperties properties)
{
if (device == null)
throw new ArgumentNullException("device");
CommandQueueSafeHandle handle = UnsafeNativeMethods.CreateCommandQueue(Handle, device.ID, properties);
return new CommandQueue(handle, this, device);
}
public extern static IntPtr clCreateCommandQueue ( IntPtr context, IntPtr device, CommandQueueProperties properties, out int errcode_ret);
public static OpenCLCommandQueue clCreateCommandQueue(OpenCLContext context, OpenCLDevice device, CommandQueueProperties properties, Error error)
{
Console.WriteLine("Calling OpenCLCommandQueue clCreateCommandQueue(OpenCLContext context, OpenCLDevice device, CommandQueueProperties properties, Error error)");
return default(OpenCLCommandQueue);
}
public static Environment CreateCLEnvironment(this string platformWildCard,
DeviceType deviceType = DeviceType.Default,
CommandQueueProperties commandQueueProperties = CommandQueueProperties.None)
{
return(new Environment(platformWildCard, deviceType, commandQueueProperties));
}
public static extern OpenCLCommandQueue clCreateCommandQueue(OpenCLContext context, OpenCLDevice device, CommandQueueProperties properties, Error error);
public static void PrintDeviceInfo(Device device)
{
if (device == null)
{
throw new ArgumentNullException("device");
}
Console.WriteLine(" CL_DEVICE_NAME: \t\t\t{0}", device.Name);
Console.WriteLine(" CL_DEVICE_VENDOR: \t\t\t{0}", device.Vendor);
Console.WriteLine(" CL_DRIVER_VERSION: \t\t\t{0}", device.DriverVersion);
Console.WriteLine(" CL_DEVICE_VERSION: \t\t\t{0}", device.Version);
if (!device.Version.StartsWith("OpenCL 1.0"))
{
Console.WriteLine(" CL_DEVICE_OPENCL_C_VERSION: \t\t{0}", device.OpenCLVersion);
}
DeviceType deviceType = device.DeviceType;
if ((deviceType & DeviceType.Cpu) != 0)
{
Console.WriteLine(" CL_DEVICE_TYPE:\t\t\t{0}", "CL_DEVICE_TYPE_CPU");
}
if ((deviceType & DeviceType.Gpu) != 0)
{
Console.WriteLine(" CL_DEVICE_TYPE:\t\t\t{0}", "CL_DEVICE_TYPE_GPU");
}
if ((deviceType & DeviceType.Accelerator) != 0)
{
Console.WriteLine(" CL_DEVICE_TYPE:\t\t\t{0}", "CL_DEVICE_TYPE_ACCELERATOR");
}
if ((deviceType & DeviceType.Default) != 0)
{
Console.WriteLine(" CL_DEVICE_TYPE:\t\t\t{0}", "CL_DEVICE_TYPE_DEFAULT");
}
Console.WriteLine(" CL_DEVICE_MAX_COMPUTE_UNITS:\t\t{0}", device.MaxComputeUnits);
Console.WriteLine(" CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS:\t{0}", device.MaxWorkItemDimensions);
Console.WriteLine(" CL_DEVICE_MAX_WORK_ITEM_SIZES:\t{0}", string.Join(" / ", device.MaxWorkItemSizes));
Console.WriteLine(" CL_DEVICE_MAX_WORK_GROUP_SIZE:\t{0}", device.MaxWorkGroupSize);
Console.WriteLine(" CL_DEVICE_MAX_CLOCK_FREQUENCY:\t{0} MHz", device.MaxClockFrequency);
Console.WriteLine(" CL_DEVICE_ADDRESS_BITS:\t\t{0}", device.AddressBits);
Console.WriteLine(" CL_DEVICE_MAX_MEM_ALLOC_SIZE:\t\t{0} MByte", device.MaxMemoryAllocationSize / (1024 * 1024));
Console.WriteLine(" CL_DEVICE_GLOBAL_MEM_SIZE:\t\t{0} MByte", device.GlobalMemorySize / (1024 * 1024));
Console.WriteLine(" CL_DEVICE_ERROR_CORRECTION_SUPPORT:\t{0}", device.ErrorCorrectionSupport ? "yes" : "no");
Console.WriteLine(" CL_DEVICE_LOCAL_MEM_TYPE:\t\t{0}", device.LocalMemoryType.ToString().ToLowerInvariant());
Console.WriteLine(" CL_DEVICE_LOCAL_MEM_SIZE:\t\t{0} KByte", device.LocalMemorySize / 1024);
Console.WriteLine(" CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE:\t{0} KByte", device.MaxConstantBufferSize / 1024);
CommandQueueProperties commandQueueProperties = device.QueueProperties;
if ((commandQueueProperties & CommandQueueProperties.OutOfOrderExecutionModeEnable) != 0)
{
Console.WriteLine(" CL_DEVICE_QUEUE_PROPERTIES:\t\t{0}", "CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE");
}
if ((commandQueueProperties & CommandQueueProperties.ProfilingEnable) != 0)
{
Console.WriteLine(" CL_DEVICE_QUEUE_PROPERTIES:\t\t{0}", "CL_QUEUE_PROFILING_ENABLE");
}
Console.WriteLine(" CL_DEVICE_IMAGE_SUPPORT:\t\t{0}", device.ImageSupport ? "yes" : "no");
Console.WriteLine(" CL_DEVICE_MAX_READ_IMAGE_ARGS:\t\t{0}", device.MaxReadImageArguments);
Console.WriteLine(" CL_DEVICE_MAX_WRITE_IMAGE_ARGS:\t\t{0}", device.MaxWriteImageArguments);
FloatingPointConfiguration fpconfig = device.SingleFloatingPointConfiguration;
Console.WriteLine(" CL_DEVICE_SINGLE_FP_CONFIG:\t\t{0}{1}{2}{3}{4}{5}",
(fpconfig & FloatingPointConfiguration.Denorm) != 0 ? "denorms " : "",
(fpconfig & FloatingPointConfiguration.InfNaN) != 0 ? "INF-quietNaNs " : "",
(fpconfig & FloatingPointConfiguration.RoundToNearest) != 0 ? "round-to-nearest " : "",
(fpconfig & FloatingPointConfiguration.RoundToZero) != 0 ? "round-to-zero " : "",
(fpconfig & FloatingPointConfiguration.RoundToInf) != 0 ? "round-to-inf " : "",
(fpconfig & FloatingPointConfiguration.Fma) != 0 ? "fma " : "");
Console.Write(" CL_DEVICE_IMAGE <dim>");
Console.WriteLine("\t\t\t2D_MAX_WIDTH\t {0}", device.Image2DMaxWidth);
Console.WriteLine("\t\t\t\t\t2D_MAX_HEIGHT\t {0}", device.Image2DMaxHeight);
Console.WriteLine("\t\t\t\t\t3D_MAX_WIDTH\t {0}", device.Image3DMaxWidth);
Console.WriteLine("\t\t\t\t\t3D_MAX_HEIGHT\t {0}", device.Image3DMaxHeight);
Console.WriteLine("\t\t\t\t\t3D_MAX_DEPTH\t {0}", device.Image3DMaxDepth);
IReadOnlyList <string> extensions = device.Extensions;
if (extensions.Count > 0)
{
Console.WriteLine();
Console.Write(" CL_DEVICE_EXTENSIONS:");
for (int i = 0; i < extensions.Count; i++)
{
if (i > 0)
{
Console.Write("\t\t");
}
Console.WriteLine("\t\t\t{0}", extensions[i]);
}
}
else
{
Console.WriteLine(" CL_DEVICE_EXTENSIONS: None");
}
if (NvDeviceAttributeQuery.IsSupported(device))
{
int computeCapabilityMajor = (int)device.GetComputeCapabilityMajorNv();
int computeCapabilityMinor = (int)device.GetComputeCapabilityMinorNv();
Console.WriteLine(" CL_DEVICE_COMPUTE_CAPABILITY_NV:\t{0}.{1}", computeCapabilityMajor, computeCapabilityMinor);
Console.WriteLine(" NUMBER OF MULTIPROCESSORS:\t\t{0}", device.MaxComputeUnits);
Console.WriteLine(" NUMBER OF CUDA CORES:\t\t\t{0}", ConvertSMVersion2Cores(computeCapabilityMajor, computeCapabilityMinor) * device.MaxComputeUnits);
Console.WriteLine(" CL_DEVICE_REGISTERS_PER_BLOCK_NV:\t{0}", device.GetRegistersPerBlockNv());
Console.WriteLine(" CL_DEVICE_WARP_SIZE_NV:\t{0}", device.GetWarpSizeNv());
Console.WriteLine(" CL_DEVICE_GPU_OVERLAP_NV:\t{0}", device.GetGpuOverlapNv());
Console.WriteLine(" CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV:\t{0}", device.GetKernelExecTimeoutNv());
Console.WriteLine(" CL_DEVICE_INTEGRATED_MEMORY_NV:\t{0}", device.GetIntegratedMemoryNv());
}
Console.Write(" CL_DEVICE_PREFERRED_VECTOR_WIDTH_<t>\t");
Console.Write("CHAR {0}, SHORT {1}, INT {2}, LONG {3}, FLOAT {4}, DOUBLE {5}",
device.PreferredVectorWidthChar,
device.PreferredVectorWidthShort,
device.PreferredVectorWidthInt,
device.PreferredVectorWidthLong,
device.PreferredVectorWidthFloat,
device.PreferredVectorWidthDouble);
Console.WriteLine();
Console.WriteLine();
Console.WriteLine();
}
public static extern IntPtr clCreateCommandQueue(IntPtr context, IntPtr device, CommandQueueProperties properties,
out OpenClErrorCode errorCode);
public static CommandQueue CreateCommandQueue(Context context, Device device, CommandQueueProperties properties)
{
ErrorCode error;
var res = NativeMethods.clCreateCommandQueue(context.handle, device.handle, properties, out error);
if (error != ErrorCode.Success)
{
throw new OpenClException(error);
}
return(new CommandQueue(res));
}
IntPtr ICommandQueueApi.clCreateCommandQueue(IntPtr context, IntPtr device, CommandQueueProperties properties, out OpenClErrorCode errorCode)
{
return(clCreateCommandQueue(context, device, properties, out errorCode));
}
