public Event EnqueueTask(Kernel kernel, Event[] events) { ClHelper.ThrowNullException(Handle); if (kernel == Kernel.Null) { throw new ArgumentNullException("kernel"); } unsafe { int num_events_in_wait_list = events == null ? 0 : events.Length; IntPtr *wait_list = stackalloc IntPtr[num_events_in_wait_list]; for (int i = 0; i < num_events_in_wait_list; ++i) { wait_list[i] = events[i].Handle; } if (events == null) { wait_list = null; } IntPtr event_ptr = IntPtr.Zero; ClHelper.GetError(Cl.EnqueueTask(Handle, kernel.Handle, (uint)num_events_in_wait_list, wait_list, &event_ptr)); return(new Event(event_ptr)); } }
public void SetDestructorCallback(Action <Image, object> notify, object user_data) { ClHelper.ThrowNullException(Handle); if (notify == null) { throw new ArgumentNullException("notify"); } unsafe { var function_ptr = IntPtr.Zero; var data = Tuple.Create(notify, user_data); var data_handle = GCHandle.Alloc(data); function_ptr = Marshal.GetFunctionPointerForDelegate(new CallbackDelegete(Callback)); try { ClHelper.GetError(Cl.SetMemObjectDestructorCallback( Handle, function_ptr, GCHandle.ToIntPtr(data_handle).ToPointer())); } catch (EntryPointNotFoundException) { data_handle.Free(); throw ClHelper.VersionException(1, 1); } catch (Exception) { data_handle.Free(); throw; } } }
public Event EnqueueWriteBuffer(Buffer buffer, bool blocking, ulong offset, ulong count, IntPtr destination, Event[] events) { ClHelper.ThrowNullException(Handle); if (buffer == Buffer.Null) { throw new ArgumentNullException("buffer"); } if (destination == IntPtr.Zero) { throw new ArgumentNullException("destination"); } unsafe { int num_events_in_wait_list = events == null ? 0 : events.Length; IntPtr *wait_list = stackalloc IntPtr[num_events_in_wait_list]; for (int i = 0; i < num_events_in_wait_list; ++i) { wait_list[i] = events[i].Handle; } if (events == null) { wait_list = null; } IntPtr event_ptr = IntPtr.Zero; ClHelper.GetError(Cl.EnqueueWriteBuffer(Handle, buffer.Handle, blocking ? 1u : 0u, new UIntPtr(offset), new UIntPtr(count), destination.ToPointer(), (uint)num_events_in_wait_list, wait_list, &event_ptr)); return(new Event(event_ptr)); } }
public void SetCallback( Action <Event, CommandExecutionStatus, object> notify, object user_data) { ClHelper.ThrowNullException(Handle); if (notify == null) { throw new ArgumentNullException("notify"); } unsafe { var function_ptr = IntPtr.Zero; var data_handle = new GCHandle(); var data = Tuple.Create(notify, user_data); data_handle = GCHandle.Alloc(data); function_ptr = Marshal.GetFunctionPointerForDelegate(new CallbackDelegete(Callback)); try { ClHelper.GetError(Cl.SetEventCallback( Handle, (int)CommandExecutionStatus.Complete, function_ptr, GCHandle.ToIntPtr(data_handle).ToPointer())); } catch (Exception) { data_handle.Free(); throw; } } }
public Event EnqueueBarrier(Event[] events) { ClHelper.ThrowNullException(Handle); try { unsafe { int num_events_in_wait_list = events == null ? 0 : events.Length; IntPtr *wait_list = stackalloc IntPtr[num_events_in_wait_list]; for (int i = 0; i < num_events_in_wait_list; ++i) { wait_list[i] = events[i].Handle; } if (events == null) { wait_list = null; } IntPtr event_ptr = IntPtr.Zero; ClHelper.GetError(Cl.EnqueueBarrierWithWaitList( Handle, (uint)num_events_in_wait_list, wait_list, &event_ptr)); return(new Event(event_ptr)); } } catch (EntryPointNotFoundException) { throw ClHelper.VersionException(1, 2); } }
public Event EnqueueUnmapBuffer( Buffer buffer, IntPtr pointer, Event[] events) { ClHelper.ThrowNullException(Handle); if (buffer == Buffer.Null) { throw new ArgumentNullException("buffer"); } unsafe { int num_events_in_wait_list = events == null ? 0 : events.Length; IntPtr *wait_list = stackalloc IntPtr[num_events_in_wait_list]; for (int i = 0; i < num_events_in_wait_list; ++i) { wait_list[i] = events[i].Handle; } if (events == null) { wait_list = null; } IntPtr event_ptr = IntPtr.Zero; ClHelper.GetError(Cl.EnqueueUnmapMemObject(Handle, buffer.Handle, pointer.ToPointer(), (uint)num_events_in_wait_list, wait_list, &event_ptr)); return(new Event(event_ptr)); } }
public void Release() { ClHelper.ThrowNullException(Handle); var error = Cl.ReleaseCommandQueue(Handle); Handle = IntPtr.Zero; ClHelper.GetError(error); }
public void ReleaseProgram() { ClHelper.ThrowNullException(Handle); int error = Cl.ReleaseProgram(Handle); Handle = IntPtr.Zero; ClHelper.GetError(error); }
public void ReleaseImage() { ClHelper.ThrowNullException(Handle); int error = Cl.ReleaseMemObject(Handle); Handle = IntPtr.Zero; ClHelper.GetError(error); }
public override bool Equals(object obj) { ClHelper.ThrowNullException(Handle); if (obj is Program) { return(Equals((Program)obj)); } return(false); }
public override bool Equals(object obj) { ClHelper.ThrowNullException(Handle); if (obj is CommandQueue) { return(Equals((CommandQueue)obj)); } return(false); }
public void EnqueueBarrier() { ClHelper.ThrowNullException(Handle); unsafe { ClHelper.GetError(Cl.EnqueueBarrier(Handle)); } }
public Event EnqueueCopyImage( Image source, Ibasa.Numerics.Vector3ul sourceOrigin, Image destination, Ibasa.Numerics.Vector3ul destinationOrigin, Ibasa.Numerics.Vector3ul region, ulong rowPitch, ulong slicePitch, Event[] events) { ClHelper.ThrowNullException(Handle); if (source == Image.Null) { throw new ArgumentNullException("source"); } if (destination == Image.Null) { throw new ArgumentNullException("destination"); } unsafe { int num_events_in_wait_list = events == null ? 0 : events.Length; IntPtr *wait_list = stackalloc IntPtr[num_events_in_wait_list]; for (int i = 0; i < num_events_in_wait_list; ++i) { wait_list[i] = events[i].Handle; } if (events == null) { wait_list = null; } IntPtr event_ptr = IntPtr.Zero; UIntPtr *sourceOrigin_ptr = stackalloc UIntPtr[3]; sourceOrigin_ptr[0] = new UIntPtr(sourceOrigin.X); sourceOrigin_ptr[1] = new UIntPtr(sourceOrigin.Y); sourceOrigin_ptr[2] = new UIntPtr(sourceOrigin.Z); UIntPtr *destinationOrigin_ptr = stackalloc UIntPtr[3]; destinationOrigin_ptr[0] = new UIntPtr(destinationOrigin.X); destinationOrigin_ptr[1] = new UIntPtr(destinationOrigin.Y); destinationOrigin_ptr[2] = new UIntPtr(destinationOrigin.Z); UIntPtr *region_ptr = stackalloc UIntPtr[3]; region_ptr[0] = new UIntPtr(region.X); region_ptr[1] = new UIntPtr(region.Y); region_ptr[2] = new UIntPtr(region.Z); ClHelper.GetError(Cl.EnqueueCopyImage(Handle, source.Handle, destination.Handle, sourceOrigin_ptr, destinationOrigin_ptr, region_ptr, (uint)num_events_in_wait_list, wait_list, &event_ptr)); return(new Event(event_ptr)); } }
public WorkGroupInfo GetWorkGroupInfo(Device device) { ClHelper.ThrowNullException(Handle); if (device == Device.Null) { throw new ArgumentNullException("device"); } return(new WorkGroupInfo(Handle, device.Handle)); }
public void SetArgument(int index, int value) { ClHelper.ThrowNullException(Handle); unsafe { ClHelper.GetError(Cl.SetKernelArg(Handle, (uint)index, (UIntPtr)sizeof(int), &value)); } }
public Event EnqueueMarker() { ClHelper.ThrowNullException(Handle); unsafe { IntPtr event_ptr = IntPtr.Zero; ClHelper.GetError(Cl.EnqueueMarker(Handle, &event_ptr)); return(new Event(event_ptr)); } }
public Event EnqueueFillBuffer(Image image, IntPtr fillColor, Ibasa.Numerics.Vector3ul origin, Ibasa.Numerics.Vector3ul region, ulong offset, ulong size, Event[] events) { ClHelper.ThrowNullException(Handle); if (image == Image.Null) { throw new ArgumentNullException("image"); } if (fillColor == IntPtr.Zero) { throw new ArgumentNullException("fillColor"); } unsafe { int num_events_in_wait_list = events == null ? 0 : events.Length; IntPtr *wait_list = stackalloc IntPtr[num_events_in_wait_list]; for (int i = 0; i < num_events_in_wait_list; ++i) { wait_list[i] = events[i].Handle; } if (events == null) { wait_list = null; } IntPtr event_ptr = IntPtr.Zero; UIntPtr *origin_ptr = stackalloc UIntPtr[3]; origin_ptr[0] = new UIntPtr(origin.X); origin_ptr[1] = new UIntPtr(origin.Y); origin_ptr[2] = new UIntPtr(origin.Z); UIntPtr *region_ptr = stackalloc UIntPtr[3]; region_ptr[0] = new UIntPtr(region.X); region_ptr[1] = new UIntPtr(region.Y); region_ptr[2] = new UIntPtr(region.Z); ClHelper.GetError(Cl.EnqueueFillImage(Handle, image.Handle, fillColor.ToPointer(), origin_ptr, region_ptr, (uint)num_events_in_wait_list, wait_list, &event_ptr)); return(new Event(event_ptr)); } }
public Event EnqueueWriteImage(Image image, bool blocking, Ibasa.Numerics.Vector3ul origin, Ibasa.Numerics.Vector3ul region, ulong rowPitch, ulong slicePitch, IntPtr source, Event[] events) { ClHelper.ThrowNullException(Handle); if (image == Image.Null) { throw new ArgumentNullException("image"); } if (source == IntPtr.Zero) { throw new ArgumentNullException("source"); } unsafe { int num_events_in_wait_list = events == null ? 0 : events.Length; IntPtr *wait_list = stackalloc IntPtr[num_events_in_wait_list]; for (int i = 0; i < num_events_in_wait_list; ++i) { wait_list[i] = events[i].Handle; } if (events == null) { wait_list = null; } IntPtr event_ptr = IntPtr.Zero; UIntPtr *origin_ptr = stackalloc UIntPtr[3]; origin_ptr[0] = new UIntPtr(origin.X); origin_ptr[1] = new UIntPtr(origin.Y); origin_ptr[2] = new UIntPtr(origin.Z); UIntPtr *region_ptr = stackalloc UIntPtr[3]; region_ptr[0] = new UIntPtr(region.X); region_ptr[1] = new UIntPtr(region.Y); region_ptr[2] = new UIntPtr(region.Z); ClHelper.GetError(Cl.EnqueueReadImage(Handle, image.Handle, blocking ? 1u : 0u, origin_ptr, region_ptr, new UIntPtr(rowPitch), new UIntPtr(slicePitch), source.ToPointer(), (uint)num_events_in_wait_list, wait_list, &event_ptr)); return(new Event(event_ptr)); } }
public void SetArgument(int index, Buffer buffer) { ClHelper.ThrowNullException(Handle); if (buffer == Buffer.Null) { throw new ArgumentNullException("buffer"); } unsafe { IntPtr value = buffer.Handle; ClHelper.GetError(Cl.SetKernelArg(Handle, (uint)index, (UIntPtr)IntPtr.Size, &value)); } }
public void SetUserEventStatus(int status) { ClHelper.ThrowNullException(Handle); if (status > 0) { throw new ArgumentException("status must be zero or negative."); } try { ClHelper.GetError(Cl.SetUserEventStatus(Handle, status)); } catch (EntryPointNotFoundException) { throw ClHelper.VersionException(1, 1); } }
public Device[] GetDevices(DeviceType deviceType) { ClHelper.ThrowNullException(Handle); unsafe { uint num_devices = 0; ClHelper.GetError(Cl.GetDeviceIDs(Handle, (uint)deviceType, 0, null, &num_devices)); IntPtr *device_ptrs = stackalloc IntPtr[(int)num_devices]; ClHelper.GetError(Cl.GetDeviceIDs(Handle, (uint)deviceType, num_devices, device_ptrs, null)); Device[] devices = new Device[num_devices]; for (uint i = 0; i < num_devices; ++i) { devices[i] = new Device(device_ptrs[i]); } return(devices); } }
public Event EnqueueMigrateBuffer( Buffer[] buffers, MemoryMigrationFlags flags, Event[] events) { ClHelper.ThrowNullException(Handle); if (buffers == null) { throw new ArgumentNullException("buffers"); } unsafe { var buffer_list = stackalloc IntPtr[buffers.Length]; for (int i = 0; i < buffers.Length; ++i) { buffer_list[i] = buffers[i].Handle; } int num_events_in_wait_list = events == null ? 0 : events.Length; IntPtr *wait_list = stackalloc IntPtr[num_events_in_wait_list]; for (int i = 0; i < num_events_in_wait_list; ++i) { wait_list[i] = events[i].Handle; } if (events == null) { wait_list = null; } IntPtr event_ptr = IntPtr.Zero; ClHelper.GetError(Cl.EnqueueMigrateMemObjects(Handle, (uint)buffers.Length, buffer_list, (ulong)flags, (uint)num_events_in_wait_list, wait_list, &event_ptr)); return(new Event(event_ptr)); } }
public Event EnqueueCopyBuffer( Buffer source, ulong sourceOffset, Buffer destination, ulong destinationOffset, ulong count, Event[] events) { ClHelper.ThrowNullException(Handle); if (source == Buffer.Null) { throw new ArgumentNullException("source"); } if (destination == Buffer.Null) { throw new ArgumentNullException("destination"); } unsafe { int num_events_in_wait_list = events == null ? 0 : events.Length; IntPtr *wait_list = stackalloc IntPtr[num_events_in_wait_list]; for (int i = 0; i < num_events_in_wait_list; ++i) { wait_list[i] = events[i].Handle; } if (events == null) { wait_list = null; } IntPtr event_ptr = IntPtr.Zero; ClHelper.GetError(Cl.EnqueueCopyBuffer(Handle, source.Handle, destination.Handle, new UIntPtr(sourceOffset), new UIntPtr(sourceOffset), new UIntPtr(count), (uint)num_events_in_wait_list, wait_list, &event_ptr)); return(new Event(event_ptr)); } }
public Event EnqueueMapBuffer( Buffer buffer, bool blocking, MapFlags flags, ulong offset, ulong size, Event[] events, out IntPtr pointer) { ClHelper.ThrowNullException(Handle); if (buffer == Buffer.Null) { throw new ArgumentNullException("buffer"); } unsafe { int num_events_in_wait_list = events == null ? 0 : events.Length; IntPtr *wait_list = stackalloc IntPtr[num_events_in_wait_list]; for (int i = 0; i < num_events_in_wait_list; ++i) { wait_list[i] = events[i].Handle; } if (events == null) { wait_list = null; } IntPtr event_ptr = IntPtr.Zero; int error; void *result = Cl.EnqueueMapBuffer(Handle, buffer.Handle, blocking ? 1u : 0u, (ulong)flags, new UIntPtr(offset), new UIntPtr(size), (uint)num_events_in_wait_list, wait_list, &event_ptr, &error); ClHelper.GetError(error); pointer = new IntPtr(result); return(new Event(event_ptr)); } }
public Event EnqueueCopyBuffer( Buffer source, long sourceOffset, Buffer destination, long destinationOffset, long count, Event[] events) { ClHelper.ThrowNullException(Handle); if (sourceOffset < 0) { throw new ArgumentOutOfRangeException("sourceOffset", sourceOffset, "sourceOffset is less than zero."); } if (destinationOffset < 0) { throw new ArgumentOutOfRangeException("destinationOffset", destinationOffset, "destinationOffset is less than zero."); } if (count < 0) { throw new ArgumentOutOfRangeException("count", count, "count is less than zero."); } return(EnqueueCopyBuffer( source, (ulong)sourceOffset, destination, (ulong)destinationOffset, (ulong)count, events)); }
public Event EnqueueFillBuffer(Buffer buffer, IntPtr pattern, ulong patternSize, ulong offset, ulong size, Event[] events) { ClHelper.ThrowNullException(Handle); if (buffer == Buffer.Null) { throw new ArgumentNullException("buffer"); } if (pattern == IntPtr.Zero) { throw new ArgumentNullException("pattern"); } unsafe { int num_events_in_wait_list = events == null ? 0 : events.Length; IntPtr *wait_list = stackalloc IntPtr[num_events_in_wait_list]; for (int i = 0; i < num_events_in_wait_list; ++i) { wait_list[i] = events[i].Handle; } if (events == null) { wait_list = null; } IntPtr event_ptr = IntPtr.Zero; ClHelper.GetError(Cl.EnqueueFillBuffer(Handle, buffer.Handle, pattern.ToPointer(), new UIntPtr(patternSize), new UIntPtr(offset), new UIntPtr(size), (uint)num_events_in_wait_list, wait_list, &event_ptr)); return(new Event(event_ptr)); } }
public void Release() { ClHelper.ThrowNullException(Handle); int error = Cl.ReleaseContext(Handle); try { // try to get the ref count var test = ReferenceCount; } catch (OpenCLException) { // if the context is released ReferenceCount will throw var data = CallbackPointers[Handle]; data.Free(); CallbackPointers.Remove(Handle); } finally { Handle = IntPtr.Zero; } ClHelper.GetError(error); }
public void EnqueueWaitForEvents(Event[] events) { ClHelper.ThrowNullException(Handle); if (events == null) { throw new ArgumentNullException("events"); } if (events.Length == 0) { throw new ArgumentException("events is empty."); } unsafe { int num_events = events == null ? 0 : events.Length; IntPtr *wait_list = stackalloc IntPtr[num_events]; for (int i = 0; i < num_events; ++i) { wait_list[i] = events[i].Handle; } ClHelper.GetError(Cl.EnqueueWaitForEvents(Handle, (uint)num_events, wait_list)); } }
public override string ToString() { ClHelper.ThrowNullException(Handle); return(string.Format("Program: {0}", Handle.ToString())); }
public bool Equals(Program other) { ClHelper.ThrowNullException(Handle); return(Handle == other.Handle); }