public Context(Device[] devices)
{
if (devices == null)
{
throw new ArgumentNullException("devices");
}
if (devices.Length == 0)
{
throw new ArgumentException("must contain at least one device", "devices");
}
if (devices.Any(device => device == null))
{
throw new ArgumentException("must not contain null values", "devices");
}
Platform = devices[0].Platform;
if (devices.Any(device => device.Platform != Platform))
{
throw new ArgumentException("all devices must belong to the same platform");
}
IntPtr[] properties = new IntPtr[3];
properties[0] = new IntPtr((Int32)ContextProperty.Platform);
properties[1] = Platform.Handle;
IntPtr[] deviceHandles = devices.Select(device => device.Handle).ToArray();
ReturnCode code;
_callback = Callback;
Handle = NativeMethods.CreateContext(properties, deviceHandles.Length, deviceHandles, _callback, IntPtr.Zero, out code);
OpenCLException.ThrowOnError(code);
_devices = (Device[])devices.Clone();
}
public String GetValue()
{
if (_value == null)
{
IntPtr ptr = Marshal.AllocHGlobal(IntPtr.Size);
try {
ReturnCode code = _createCallback(_handle, _name, IntPtr.Zero, IntPtr.Zero, ptr);
OpenCLException.ThrowOnError(code);
IntPtr size = Marshal.ReadIntPtr(ptr);
if (size.ToInt32() > 0)
{
ptr = Marshal.AllocHGlobal(size);
_createCallback(_handle, _name, size, ptr, IntPtr.Zero);
_value = Marshal.PtrToStringAnsi(ptr, size.ToInt32() - 1);
}
else
{
_value = "";
}
} finally {
Marshal.FreeHGlobal(ptr);
}
}
return(_value);
}
public void WaitForEvents(params EventObject[] events)
{
if (_disposed)
{
throw new ObjectDisposedException(GetType().FullName);
}
if (events == null)
{
throw new ArgumentNullException("events");
}
if (events.Length == 0)
{
throw new ArgumentException("events");
}
IntPtr[] handles;
Int32 handlesLength;
if (!Helpers.TryGetEventHandles(events, out handles, out handlesLength))
{
throw new ArgumentException("events");
}
ReturnCode code = NativeMethods.WaitForEvents(handlesLength, handles);
OpenCLException.ThrowOnError(code);
}
public void Flush()
{
if (_disposed)
{
throw new ObjectDisposedException(GetType().FullName);
}
ReturnCode code = NativeMethods.Flush(_handle);
OpenCLException.ThrowOnError(code);
}
public void CompleteEnqueuedCommands()
{
if (_disposed)
{
throw new ObjectDisposedException(GetType().FullName);
}
ReturnCode code = NativeMethods.Finish(_handle);
OpenCLException.ThrowOnError(code);
}
public static Platform[] GetPlatforms()
{
Int32 count;
ReturnCode code = NativeMethods.GetPlatformIDs(0, null, out count);
OpenCLException.ThrowOnError(code);
IntPtr[] handles = new IntPtr[count];
code = NativeMethods.GetPlatformIDs(count, handles, out count);
OpenCLException.ThrowOnError(code);
return(handles.Select(handle => new Platform(handle)).ToArray());
}
//public void ReadBuffer(Buffer source, Array destination) {
// if (_disposed) {
// throw new ObjectDisposedException(GetType().FullName);
// }
// if (source == null) {
// throw new ArgumentNullException("source");
// }
// if (destination == null) {
// throw new ArgumentNullException("destination");
// }
// GCHandle pinnedDestination = GCHandle.Alloc(destination, GCHandleType.Pinned);
// ReturnCode code = NativeMethods.ReadBuffer(
// _handle,
// source.Handle,
// OpenCLBoolean.True,
// IntPtr.Zero,
// new IntPtr(System.Buffer.ByteLength(destination)),
// pinnedDestination.AddrOfPinnedObject(),
// 0,
// IntPtr.Zero,
// IntPtr.Zero
// );
// pinnedDestination.Free();
// OpenCLException.ThrowOnError(code);
//}
public EventObject StartReadBuffer(Buffer source, Array destination, Int64 destinationIndex, Int64 destinationCount, params EventObject[] predecessors)
{
if (_disposed)
{
throw new ObjectDisposedException(GetType().FullName);
}
if (source == null)
{
throw new ArgumentNullException("source");
}
if (destination == null)
{
throw new ArgumentNullException("destination");
}
Int64 size = System.Buffer.ByteLength(destination);
if (destinationIndex < 0 || destinationCount <= 0 || destinationIndex + destinationCount > size)
{
throw new ArgumentOutOfRangeException("destinationIndex/destinationCount");
}
Debug.Assert(destinationCount == (Int64)source.Size);
IntPtr[] handles;
Int32 handlesLength;
if (!Helpers.TryGetEventHandles(predecessors, out handles, out handlesLength))
{
throw new ArgumentException("predecessors");
}
GCHandle pinnedDestination = GCHandle.Alloc(destination, GCHandleType.Pinned);
EventObject result = null;
try {
IntPtr newEvent;
ReturnCode code = NativeMethods.BeginReadBuffer(
_handle,
source.Handle,
OpenCLBoolean.False,
IntPtr.Zero,
new IntPtr((Int64)destinationCount),
new IntPtr(pinnedDestination.AddrOfPinnedObject().ToInt64() + (Int64)destinationIndex),
handlesLength,
handles,
out newEvent
);
OpenCLException.ThrowOnError(code);
result = new EventObject(newEvent, pinnedDestination);
} finally {
if (result == null)
{
pinnedDestination.Free();
}
}
return(result);
}
public Buffer CreateBuffer(UInt64 size, BufferFlags flags)
{
if (_disposed)
{
throw new ObjectDisposedException(GetType().FullName);
}
ReturnCode code;
IntPtr handle = NativeMethods.CreateBuffer(Handle, flags, new UIntPtr(size), IntPtr.Zero, out code);
OpenCLException.ThrowOnError(code);
return(new Buffer(handle, size));
}
public Kernel CreateKernel(String name)
{
if (_disposed)
{
throw new ObjectDisposedException(GetType().FullName);
}
ReturnCode code;
IntPtr kernelHandle = NativeMethods.CreateKernel(Handle, name, out code);
OpenCLException.ThrowOnError(code);
return(new Kernel(kernelHandle));
}
public EventObject StartWriteBufferRect(Array source, Buffer destination, IntPtr hostOriginX, IntPtr hostOriginY, IntPtr hostOriginZ, IntPtr regionX, IntPtr regionY, IntPtr regionZ, IntPtr sizeX, IntPtr sizeXY, params EventObject[] predecessors)
{
if (_disposed)
{
throw new ObjectDisposedException(GetType().FullName);
}
if (source == null)
{
throw new ArgumentNullException("source");
}
if (destination == null)
{
throw new ArgumentNullException("destination");
}
IntPtr[] handles = null;
Int32 handlesLength = 0;
if (!Helpers.TryGetEventHandles(predecessors, out handles, out handlesLength))
{
throw new ArgumentException("predecessors");
}
GCHandle pinnedSource = GCHandle.Alloc(source, GCHandleType.Pinned);
EventObject result = null;
try {
IntPtr newEvent;
ReturnCode code = NativeMethods.BeginWriteBufferRect(
_handle,
destination.Handle,
OpenCLBoolean.False,
new IntPtr[] { IntPtr.Zero, IntPtr.Zero, IntPtr.Zero },
new IntPtr[] { hostOriginX, hostOriginY, hostOriginZ },
new IntPtr[] { regionX, regionY, regionZ },
IntPtr.Zero,
IntPtr.Zero,
sizeX,
sizeXY,
pinnedSource.AddrOfPinnedObject(),
handlesLength,
handles,
out newEvent
);
OpenCLException.ThrowOnError(code);
result = new EventObject(newEvent, pinnedSource);
} finally {
if (result == null)
{
pinnedSource.Free();
}
}
return(result);
}
public CommandQueue(Context context, Device device, CommandQueueFlags flags)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (device == null)
{
throw new ArgumentNullException("device");
}
_context = context;
_device = device;
ReturnCode code;
_handle = NativeMethods.CreateCommandQueue(context.Handle, device.Handle, flags, out code);
OpenCLException.ThrowOnError(code);
}
public TValue GetValue()
{
if (!_created)
{
Int32 size = Marshal.SizeOf(typeof(TValue));
IntPtr buffer = Marshal.AllocHGlobal(size);
try {
ReturnCode code = _createCallback(_handle, _name, new IntPtr(size), buffer, IntPtr.Zero);
OpenCLException.ThrowOnError(code);
_value = (TValue)Marshal.PtrToStructure(buffer, typeof(TValue));
_created = true;
} finally {
Marshal.FreeHGlobal(buffer);
}
}
return(_value);
}
public Device[] GetDevices(DeviceType types)
{
Int32 count;
ReturnCode code = NativeMethods.GetDeviceIDs(Handle, types, 0, null, out count);
if (code == ReturnCode.DeviceNotFound)
{
return(new Device[0]);
}
else
{
OpenCLException.ThrowOnError(code);
IntPtr[] handles = new IntPtr[count];
code = NativeMethods.GetDeviceIDs(Handle, types, count, handles, out count);
OpenCLException.ThrowOnError(code);
return(handles.Select(handle => new Device(handle, this)).ToArray());
}
}
public EventObject(IntPtr handle, GCHandle?pinnedArgumentHandle)
{
_handle = handle;
_pinnedArgumentHandle = pinnedArgumentHandle;
_lock = new Object();
_callbacks = new List <EventObjectCompletionCallback>();
_queuedTimeCache = new GetInfoStructCache <CommandProfilingInfo, UInt64>(NativeMethods.GetEventProfilingInfo, _handle, CommandProfilingInfo.Queued);
_submittedTimeCache = new GetInfoStructCache <CommandProfilingInfo, UInt64>(NativeMethods.GetEventProfilingInfo, _handle, CommandProfilingInfo.Submitted);
_startedTimeCache = new GetInfoStructCache <CommandProfilingInfo, UInt64>(NativeMethods.GetEventProfilingInfo, _handle, CommandProfilingInfo.Started);
_finishedTimeCache = new GetInfoStructCache <CommandProfilingInfo, UInt64>(NativeMethods.GetEventProfilingInfo, _handle, CommandProfilingInfo.Ended);
_internalCallbackDelegate = Callback;
ReturnCode code = NativeMethods.SetEventCallback(_handle, CommandExecutionStatus.Complete, _internalCallbackDelegate, IntPtr.Zero);
OpenCLException.ThrowOnError(code);
lock (rootCallbacks)
{
rootCallbacks.Add(this);
}
}
public EventObject StartKernel(Kernel kernel, UInt64[] globalRange, UInt64[] localRange, params EventObject[] predecessors)
{
if (_disposed)
{
throw new ObjectDisposedException(GetType().FullName);
}
if (kernel == null)
{
throw new ArgumentNullException("kernel");
}
if (globalRange == null)
{
throw new ArgumentNullException("globalRange");
}
Int32 dimension = globalRange.Length;
if (localRange != null && localRange.Length != dimension)
{
throw new ArgumentException("globalRange and localRange must have the same dimensions");
}
IntPtr[] handles;
Int32 handlesLength;
if (!Helpers.TryGetEventHandles(predecessors, out handles, out handlesLength))
{
throw new ArgumentException("predecessors");
}
IntPtr newEvent;
ReturnCode code = NativeMethods.EnqueueNDRangeKernel(
_handle,
kernel.Handle,
dimension,
null,
ToUIntPtrArray(globalRange),
ToUIntPtrArray(localRange),
handlesLength,
handles,
out newEvent
);
OpenCLException.ThrowOnError(code);
return(new EventObject(newEvent, null));
}
public EventObject StartCopyBuffer(Buffer source, Buffer destination, params EventObject[] predecessors)
{
if (_disposed)
{
throw new ObjectDisposedException(GetType().FullName);
}
if (source == null)
{
throw new ArgumentNullException("source");
}
if (destination == null)
{
throw new ArgumentNullException("destination");
}
if (source.Size != destination.Size)
{
throw new ArgumentException("sizes of arguments are not equal");
}
IntPtr[] handles = null;
Int32 handlesLength = 0;
if (!Helpers.TryGetEventHandles(predecessors, out handles, out handlesLength))
{
throw new ArgumentException("predecessors");
}
IntPtr newEvent;
ReturnCode code = NativeMethods.CopyBuffer(
_handle,
source.Handle,
destination.Handle,
IntPtr.Zero,
IntPtr.Zero,
new IntPtr((Int64)source.Size),
handlesLength,
handles,
out newEvent
);
OpenCLException.ThrowOnError(code);
return(new EventObject(newEvent, null));
}
void SetArgument(Int32 index, Int64 size, IntPtr value)
{
ReturnCode code = NativeMethods.SetKernelArgument(Handle, index, new IntPtr(size), value);
OpenCLException.ThrowOnError(code);
}
public CompiledProgram Compile(String source, String options)
{
if (_disposed)
{
throw new ObjectDisposedException(GetType().FullName);
}
if (source == null)
{
throw new ArgumentNullException("source");
}
lock (_lock) {
ReturnCode code;
IntPtr handle = NativeMethods.CreateProgramWithSource(Handle, 1, new String[] { source }, new IntPtr[] { new IntPtr(source.Length) }, out code);
OpenCLException.ThrowOnError(code);
IntPtr[] devices = Array.ConvertAll(_devices, device => device.Handle);
code = NativeMethods.BuildProgram(handle, devices.Length, devices, options, IntPtr.Zero, IntPtr.Zero);
if (code == ReturnCode.BuildProgramFailure)
{
Console.WriteLine(source);
String[] logs = Array.ConvertAll(_devices, device => {
//String log = null;
//IntPtr currentSize = new IntPtr(1);
//IntPtr actualSize;
//Boolean exit = false;
//do {
// IntPtr characters = Marshal.AllocHGlobal(currentSize);
// try {
// System.Diagnostics.Debugger.Launch();
// code = NativeMethods.GetProgramBuildInfoString(handle, device.Handle, ProgramBuildInfo.BuildLog, currentSize, characters, out actualSize);
// OpenCLException.ThrowOnError(code);
// if (currentSize == actualSize) {
// log = Marshal.PtrToStringAnsi(characters, currentSize.ToInt32());
// exit = true;
// } else {
// currentSize = actualSize;
// }
// } finally {
// Marshal.FreeHGlobal(characters);
// }
//} while (!exit);
IntPtr size = IntPtr.Zero;
ReturnCode code2 = NativeMethods.GetProgramBuildInfoString(handle, device.Handle, ProgramBuildInfo.BuildLog, IntPtr.Zero, IntPtr.Zero, out size);
OpenCLException.ThrowOnError(code2);
IntPtr characters = Marshal.AllocHGlobal(size);
code2 = NativeMethods.GetProgramBuildInfoString(handle, device.Handle, ProgramBuildInfo.BuildLog, size, characters, out size);
OpenCLException.ThrowOnError(code2);
String log = Marshal.PtrToStringAnsi(characters, size.ToInt32());
Marshal.FreeHGlobal(characters);
Console.WriteLine(log);
return(log);
});
throw new BuildProgramFailureOpenCLException(logs);
}
else
{
try {
OpenCLException.ThrowOnError(code);
} catch (OpenCLException) {
NativeMethods.ReleaseProgram(handle);
throw;
}
return(new CompiledProgram(handle));
}
}
}