Example #1
0
        internal Event(EventSafeHandle handle)
        {
            if (handle == null)
            {
                throw new ArgumentNullException(nameof(handle));
            }

            _handle = handle;
        }
Example #2
0
        public static void SetUserEventStatus(EventSafeHandle @event, ExecutionStatus executionStatus)
        {
            if (@event == null)
            {
                throw new ArgumentNullException("event");
            }

            ErrorHandler.ThrowOnFailure(clSetUserEventStatus(@event, executionStatus));
        }
 private static extern ErrorCode clEnqueueNDRangeKernel(
     CommandQueueSafeHandle commandQueue,
     KernelSafeHandle kernel,
     uint workDim,
     [In, MarshalAs(UnmanagedType.LPArray)] IntPtr[] globalWorkOffset,
     [In, MarshalAs(UnmanagedType.LPArray)] IntPtr[] globalWorkSize,
     [In, MarshalAs(UnmanagedType.LPArray)] IntPtr[] localWorkSize,
     uint numEventsInWaitList,
     [In, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(SafeHandleArrayMarshaler))] EventSafeHandle[] eventWaitList,
     out EventSafeHandle @event);
 private static extern ErrorCode clEnqueueNativeKernel(
     CommandQueueSafeHandle commandQueue,
     NativeKernelFunction userFunction,
     IntPtr args,
     IntPtr cbArgs,
     uint numMemObjects,
     [In, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(SafeHandleArrayMarshaler))] MemObjectSafeHandle[] memList,
     [In, MarshalAs(UnmanagedType.LPArray)] IntPtr[] argsMemLoc,
     uint numEventsInWaitList,
     [In, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(SafeHandleArrayMarshaler))] EventSafeHandle[] eventWaitList,
     out EventSafeHandle @event);
Example #5
0
        public Event EnqueueCopyImage(Image sourceImage, Image destinationImage, BufferCoordinates sourceOrigin, BufferCoordinates destinationOrigin, BufferSize region, params Event[] eventWaitList)
        {
            EventSafeHandle[] eventHandles = null;
            if (eventWaitList != null)
            {
                eventHandles = Array.ConvertAll(eventWaitList, @event => @event.Handle);
            }

            EventSafeHandle handle = UnsafeNativeMethods.EnqueueCopyImage(Handle, sourceImage.Handle, destinationImage.Handle, ref sourceOrigin, ref destinationOrigin, ref region, eventHandles);

            return(new Event(handle));
        }
Example #6
0
        public Event EnqueueFillImage(Image image, uint[] fillColor, BufferCoordinates origin, BufferSize region, params Event[] eventWaitList)
        {
            EventSafeHandle[] eventHandles = null;
            if (eventWaitList != null)
            {
                eventHandles = Array.ConvertAll(eventWaitList, @event => @event.Handle);
            }

            EventSafeHandle handle = UnsafeNativeMethods.EnqueueFillImage(Handle, image.Handle, fillColor, ref origin, ref region, eventHandles);

            return(new Event(handle));
        }
Example #7
0
        public Event EnqueueWriteImage(Image image, bool blocking, BufferCoordinates origin, BufferSize region, long inputRowPitch, long inputSlicePitch, IntPtr source, params Event[] eventWaitList)
        {
            EventSafeHandle[] eventHandles = null;
            if (eventWaitList != null)
            {
                eventHandles = Array.ConvertAll(eventWaitList, @event => @event.Handle);
            }

            EventSafeHandle handle = UnsafeNativeMethods.EnqueueWriteImage(Handle, image.Handle, blocking, ref origin, ref region, (IntPtr)inputRowPitch, (IntPtr)inputSlicePitch, source, eventHandles);

            return(new Event(handle));
        }
Example #8
0
        public Event EnqueueMapBuffer(Buffer buffer, bool blocking, MapFlags mapFlags, long offset, long size, out IntPtr mappedPointer, params Event[] eventWaitList)
        {
            EventSafeHandle[] eventHandles = null;
            if (eventWaitList != null)
            {
                eventHandles = Array.ConvertAll(eventWaitList, @event => @event.Handle);
            }

            EventSafeHandle handle = UnsafeNativeMethods.EnqueueMapBuffer(Handle, buffer.Handle, blocking, mapFlags, (IntPtr)offset, (IntPtr)size, out mappedPointer, eventHandles);

            return(new Event(handle));
        }
Example #9
0
        public Event EnqueueCopyBufferRect(Buffer source, Buffer destination, BufferCoordinates sourceOrigin, BufferCoordinates destinationOrigin, BufferSize region, long sourceRowPitch, long sourceSlicePitch, long destinationRowPitch, long destinationSlicePitch, params Event[] eventWaitList)
        {
            EventSafeHandle[] eventHandles = null;
            if (eventWaitList != null)
            {
                eventHandles = Array.ConvertAll(eventWaitList, @event => @event.Handle);
            }

            EventSafeHandle handle = UnsafeNativeMethods.EnqueueCopyBufferRect(Handle, source.Handle, destination.Handle, ref sourceOrigin, ref destinationOrigin, ref region, (IntPtr)sourceRowPitch, (IntPtr)sourceSlicePitch, (IntPtr)destinationRowPitch, (IntPtr)destinationSlicePitch, eventHandles);

            return(new Event(handle));
        }
Example #10
0
        public Event EnqueueCopyBuffer(Buffer source, Buffer destination, long sourceOffset, long destinationOffset, long size, params Event[] eventWaitList)
        {
            EventSafeHandle[] eventHandles = null;
            if (eventWaitList != null)
            {
                eventHandles = Array.ConvertAll(eventWaitList, @event => @event.Handle);
            }

            EventSafeHandle handle = UnsafeNativeMethods.EnqueueCopyBuffer(Handle, source.Handle, destination.Handle, (IntPtr)sourceOffset, (IntPtr)destinationOffset, (IntPtr)size, eventHandles);

            return(new Event(handle));
        }
Example #11
0
        public Event EnqueueUnmapMemObject(MemObject memObject, IntPtr mappedPointer, params Event[] eventWaitList)
        {
            EventSafeHandle[] eventHandles = null;
            if (eventWaitList != null)
            {
                eventHandles = Array.ConvertAll(eventWaitList, @event => @event.Handle);
            }

            EventSafeHandle handle = UnsafeNativeMethods.EnqueueUnmapMemObject(Handle, memObject.BaseHandle, mappedPointer, eventHandles);

            return(new Event(handle));
        }
Example #12
0
        /// <summary>
        /// Enqueues a command to execute a <see cref="Kernel"/> on this command queue's <see cref="Device"/>.
        /// </summary>
        /// <remarks>
        /// The kernel is executed using a single work-item.
        ///
        /// <para><see cref="EnqueueTask"/> is equivalent to calling
        /// <see cref="EnqueueNDRangeKernel(Kernel, IntPtr, IntPtr, Event[])"/> with
        /// <em>globalWorkSize</em> set to 1, and <em>localWorkSize</em> set to 1.</para>
        /// </remarks>
        /// <param name="kernel">A valid <see cref="Kernel"/> object.</param>
        /// <param name="eventWaitList">The events that need to be complete before this
        /// command is executed. If the list is null or empty, this command does not
        /// wait on any event to complete.</param>
        /// <returns>Returns an event object that identifies this particular kernel execution instance.</returns>
        public Event EnqueueTask(Kernel kernel, params Event[] eventWaitList)
        {
            EventSafeHandle[] eventHandles = null;
            if (eventWaitList != null)
            {
                eventHandles = Array.ConvertAll(eventWaitList, @event => @event.Handle);
            }

            EventSafeHandle handle = UnsafeNativeMethods.EnqueueTask(Handle, kernel.Handle, eventHandles);

            return(new Event(handle));
        }
Example #13
0
        public Event EnqueueWriteBuffer(Buffer buffer, bool blocking, long offset, long size, IntPtr source, params Event[] eventWaitList)
        {
            EventSafeHandle[] eventHandles = null;
            if (eventWaitList != null)
            {
                eventHandles = Array.ConvertAll(eventWaitList, @event => @event.Handle);
            }

            EventSafeHandle handle = UnsafeNativeMethods.EnqueueWriteBuffer(Handle, buffer.Handle, blocking, (IntPtr)offset, (IntPtr)size, source, eventHandles);

            return(new Event(handle));
        }
Example #14
0
        /// <summary>
        /// A synchronization point that enqueues a barrier operation.
        /// </summary>
        /// <remarks>
        /// Enqueues a barrier command which waits for all events in
        /// <paramref name="eventWaitList"/> to complete, or if
        /// <paramref name="eventWaitList"/> is empty it waits for all previously enqueued
        /// commands to complete before it completes. This command blocks command execution,
        /// that is, any commands enqueued after it do not execute until it completes. This
        /// command returns an event which can be waited on, i.e. this event can be waited
        /// on to ensure that all events either in the <paramref name="eventWaitList"/>
        /// or all previously enqueued commands, queued before this command, have completed.
        /// </remarks>
        /// <param name="eventWaitList">The events that need to be complete before this
        /// command is executed. If the list is null or empty, this command waits until
        /// all previous enqueued commands have completed.</param>
        /// <returns>Returns an event object that identifies this particular command.</returns>
        public Event EnqueueBarrier(params Event[] eventWaitList)
        {
            EventSafeHandle[] eventHandles = null;
            if (eventWaitList != null)
            {
                eventHandles = Array.ConvertAll(eventWaitList, @event => @event.Handle);
            }

            EventSafeHandle handle = UnsafeNativeMethods.EnqueueBarrierWithWaitList(Handle, eventHandles);

            return(new Event(handle));
        }
Example #15
0
        public Event EnqueueNDRangeKernel(Kernel kernel, IntPtr[] globalWorkOffset, IntPtr[] globalWorkSize, IntPtr[] localWorkSize, params Event[] eventWaitList)
        {
            EventSafeHandle[] eventHandles = null;
            if (eventWaitList != null)
            {
                eventHandles = Array.ConvertAll(eventWaitList, @event => @event.Handle);
            }

            EventSafeHandle handle = UnsafeNativeMethods.EnqueueNDRangeKernel(Handle, kernel.Handle, globalWorkOffset, globalWorkSize, localWorkSize, eventHandles);

            return(new Event(handle));
        }
Example #16
0
        public Event EnqueueWriteBufferRect(Buffer buffer, bool blocking, BufferCoordinates bufferOrigin, BufferCoordinates hostOrigin, BufferSize region, long bufferRowPitch, long bufferSlicePitch, long hostRowPitch, long hostSlicePitch, IntPtr source, params Event[] eventWaitList)
        {
            EventSafeHandle[] eventHandles = null;
            if (eventWaitList != null)
            {
                eventHandles = Array.ConvertAll(eventWaitList, @event => @event.Handle);
            }

            EventSafeHandle handle = UnsafeNativeMethods.EnqueueWriteBufferRect(Handle, buffer.Handle, blocking, ref bufferOrigin, ref hostOrigin, ref region, (IntPtr)bufferRowPitch, (IntPtr)bufferSlicePitch, (IntPtr)hostRowPitch, (IntPtr)hostSlicePitch, source, eventHandles);

            return(new Event(handle));
        }
Example #17
0
        public Event EnqueueCopyImageToBuffer <T>(Image sourceImage, Buffer <T> destinationBuffer, BufferCoordinates sourceOrigin, BufferSize region, long destinationOffset, params Event[] eventWaitList)
            where T : struct
        {
            EventSafeHandle[] eventHandles = null;
            if (eventWaitList != null)
            {
                eventHandles = Array.ConvertAll(eventWaitList, @event => @event.Handle);
            }

            EventSafeHandle handle = UnsafeNativeMethods.EnqueueCopyImageToBuffer(Handle, sourceImage.Handle, destinationBuffer.Handle, ref sourceOrigin, ref region, (IntPtr)destinationOffset, eventHandles);

            return(new Event(handle));
        }
Example #18
0
        public Event EnqueueCopyBufferToImage <T>(Buffer <T> sourceBuffer, Image destinationImage, long sourceOffset, BufferCoordinates destinationOrigin, BufferSize region, params Event[] eventWaitList)
            where T : struct
        {
            EventSafeHandle[] eventHandles = null;
            if (eventWaitList != null)
            {
                eventHandles = Array.ConvertAll(eventWaitList, @event => @event.Handle);
            }

            EventSafeHandle handle = UnsafeNativeMethods.EnqueueCopyBufferToImage(Handle, sourceBuffer.Handle, destinationImage.Handle, (IntPtr)sourceOffset, ref destinationOrigin, ref region, eventHandles);

            return(new Event(handle));
        }
Example #19
0
        public static EventSafeHandle CreateUserEvent(ContextSafeHandle context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            ErrorCode       errorCode;
            EventSafeHandle handle = clCreateUserEvent(context, out errorCode);

            ErrorHandler.ThrowOnFailure(errorCode);
            return(handle);
        }
Example #20
0
        public Event EnqueueReadBuffer <T>(Buffer <T> buffer, bool blocking, long offset, long size, IntPtr destination, params Event[] eventWaitList)
            where T : struct
        {
            EventSafeHandle[] eventHandles = null;
            if (eventWaitList != null)
            {
                eventHandles = Array.ConvertAll(eventWaitList, @event => @event.Handle);
            }

            EventSafeHandle handle = UnsafeNativeMethods.EnqueueReadBuffer(Handle, buffer.Handle, blocking, (IntPtr)offset, (IntPtr)size, destination, eventHandles);

            return(new Event(handle));
        }
Example #21
0
        public Event EnqueueMapImage(Image image, bool blocking, MapFlags mapFlags, BufferCoordinates origin, BufferSize region, out long rowPitch, out long slicePitch, out IntPtr mappedPointer, params Event[] eventWaitList)
        {
            EventSafeHandle[] eventHandles = null;
            if (eventWaitList != null)
            {
                eventHandles = Array.ConvertAll(eventWaitList, @event => @event.Handle);
            }

            IntPtr          imageRowPitch;
            IntPtr          imageSlicePitch;
            EventSafeHandle handle = UnsafeNativeMethods.EnqueueMapImage(Handle, image.Handle, blocking, mapFlags, ref origin, ref region, out imageRowPitch, out imageSlicePitch, out mappedPointer, eventHandles);

            rowPitch   = imageRowPitch.ToInt64();
            slicePitch = imageSlicePitch.ToInt64();
            return(new Event(handle));
        }
Example #22
0
        public Event EnqueueMigrateMemObjects(MemObject[] memObjects, MigrationFlags flags, params Event[] eventWaitList)
        {
            MemObjectSafeHandle[] memHandles = null;
            if (memObjects != null)
            {
                memHandles = Array.ConvertAll(memObjects, mem => mem.BaseHandle);
            }

            EventSafeHandle[] eventHandles = null;
            if (eventWaitList != null)
            {
                eventHandles = Array.ConvertAll(eventWaitList, @event => @event.Handle);
            }

            EventSafeHandle handle = UnsafeNativeMethods.EnqueueMigrateMemObjects(Handle, memHandles, flags, eventHandles);

            return(new Event(handle));
        }
Example #23
0
        public static T GetEventInfo <T>(EventSafeHandle @event, EventParameterInfo <T> 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(clGetEventInfo(@event, 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(clGetEventInfo(@event, parameter.ParameterInfo.Name, requiredSize, memory, out actualSize));
                return(parameter.ParameterInfo.Deserialize(actualSize, memory));
            }
            finally
            {
                Marshal.FreeHGlobal(memory);
            }
        }
 private static extern ErrorCode clEnqueueTask(
     CommandQueueSafeHandle commandQueue,
     KernelSafeHandle kernel,
     uint numEventsInWaitList,
     [In, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(SafeHandleArrayMarshaler))] EventSafeHandle[] eventWaitList,
     out EventSafeHandle @event);
Example #25
0
 private static extern ErrorCode clGetEventInfo(
     EventSafeHandle @event,
     int paramName,
     UIntPtr paramValueSize,
     IntPtr paramValue,
     out UIntPtr paramValueSizeRet);
Example #26
0
 private static extern ErrorCode clSetUserEventStatus(EventSafeHandle @event, ExecutionStatus executionStatus);
Example #27
0
 public static void SetEventCallback(EventSafeHandle @event, ExecutionStatus executionCallbackType, EventCallback eventNotify, IntPtr userData)
 {
     throw new NotImplementedException();
 }
Example #28
0
 private static extern ErrorCode clSetEventCallback(
     EventSafeHandle @event,
     ExecutionStatus executionCallbackType,
     EventCallback eventNotify,
     IntPtr userData);
Example #29
0
        public Event CreateUserEvent()
        {
            EventSafeHandle handle = UnsafeNativeMethods.CreateUserEvent(Handle);

            return(new Event(handle));
        }
Example #30
0
 private static extern ErrorCode clRetainEvent(EventSafeHandle @event);