C# Bindings.CLEventHandle类代码示例

 ComputeErrorCode ICL11.EnqueueWriteBufferRect(CLCommandQueueHandle command_queue, CLMemoryHandle buffer, bool blocking_write,
                                               ref SysIntX3 buffer_offset, ref SysIntX3 host_offset, ref SysIntX3 region,
                                               IntPtr buffer_row_pitch, IntPtr buffer_slice_pitch, IntPtr host_row_pitch,
                                               IntPtr host_slice_pitch, IntPtr ptr, int num_events_in_wait_list,
                                               CLEventHandle[] event_wait_list, CLEventHandle[] new_event)
 {
     return EnqueueWriteBufferRect(command_queue, buffer, blocking_write, ref buffer_offset, ref host_offset, ref region, buffer_row_pitch, buffer_slice_pitch, host_row_pitch, host_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, new_event);
 }

 ComputeErrorCode ICL11.EnqueueCopyBufferRect(CLCommandQueueHandle command_queue, CLMemoryHandle src_buffer,
                                              CLMemoryHandle dst_buffer, ref SysIntX3 src_origin, ref SysIntX3 dst_origin,
                                              ref SysIntX3 region, IntPtr src_row_pitch, IntPtr src_slice_pitch,
                                              IntPtr dst_row_pitch, IntPtr dst_slice_pitch, int num_events_in_wait_list,
                                              CLEventHandle[] event_wait_list, CLEventHandle[] new_event)
 {
     return EnqueueCopyBufferRect(command_queue, src_buffer, dst_buffer, ref src_origin, ref dst_origin, ref region, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, new_event);
 }

        internal ComputeEvent(CLEventHandle handle, ComputeCommandQueue queue)
        {
            Handle = handle;
            SetID(Handle.Value);

            CommandQueue = queue;
            Type = (ComputeCommandType)GetInfo<CLEventHandle, ComputeEventInfo, int>(Handle, ComputeEventInfo.CommandType, CLInterface.CL10.GetEventInfo);
            Context = queue.Context;

            if (ComputeTools.ParseVersionString(CommandQueue.Device.Platform.Version, 1) > new Version(1, 0))
                HookNotifier();
        }

        internal ComputeEvent(CLEventHandle handle, ComputeCommandQueue queue)
        {
            Handle = handle;
            SetID(Handle.Value);

            CommandQueue = queue;
            Type = (ComputeCommandType)GetInfo<CLEventHandle, ComputeEventInfo, int>(Handle, ComputeEventInfo.CommandType, CL10.GetEventInfo);
            Context = queue.Context;

            if (ComputeTools.ParseVersionString(CommandQueue.Device.Platform.Version, 1) > new Version(1, 0))
                HookNotifier();

            Trace.WriteLine("Create " + this + " in Thread(" + Thread.CurrentThread.ManagedThreadId + ").", "Information");
        }

 public static extern ComputeErrorCode GetEventProfilingInfo(
     CLEventHandle @event,
     ComputeCommandProfilingInfo param_name,
     IntPtr param_value_size,
     IntPtr param_value,
     out IntPtr param_value_size_ret);

 private void StatusNotify(CLEventHandle eventHandle, int cmdExecStatusOrErr, IntPtr userData)
 {
     status = new ComputeCommandStatusArgs(this, (ComputeCommandExecutionStatus)cmdExecStatusOrErr);
     switch (cmdExecStatusOrErr)
     {
         case (int)ComputeCommandExecutionStatus.Complete: OnCompleted(this, status); break;
         default: OnAborted(this, status); break;
     }
 }

 public ComputeErrorCode GetEventProfilingInfo(CLEventHandle @event, ComputeCommandProfilingInfo param_name, IntPtr param_value_size, IntPtr param_value, out IntPtr param_value_size_ret)
 {
     return StaticGetEventProfilingInfo(@event, param_name, param_value_size, param_value, out param_value_size_ret);
 }

 public ComputeErrorCode EnqueueWriteImage(CLCommandQueueHandle command_queue, CLMemoryHandle image, [MarshalAs(UnmanagedType.Bool)] bool blocking_write, ref SysIntX3 origin, ref SysIntX3 region, IntPtr input_row_pitch, IntPtr input_slice_pitch, IntPtr ptr, Int32 num_events_in_wait_list, [MarshalAs(UnmanagedType.LPArray)] CLEventHandle[] event_wait_list, out CLEventHandle new_event)
 {
     return StaticEnqueueWriteImage(command_queue, image, blocking_write, ref origin, ref region, input_row_pitch, input_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, out new_event);
 }

 public ComputeErrorCode EnqueueWriteBuffer(CLCommandQueueHandle command_queue, CLMemoryHandle buffer, [MarshalAs(UnmanagedType.Bool)] bool blocking_write, IntPtr offset, IntPtr cb, IntPtr ptr, Int32 num_events_in_wait_list, [MarshalAs(UnmanagedType.LPArray)] CLEventHandle[] event_wait_list, out CLEventHandle new_event)
 {
     return StaticEnqueueWriteBuffer(command_queue, buffer, blocking_write, offset, cb, ptr, num_events_in_wait_list, event_wait_list, out new_event);
 }

 public ComputeErrorCode EnqueueTask(CLCommandQueueHandle command_queue, CLKernelHandle kernel, Int32 num_events_in_wait_list, [MarshalAs(UnmanagedType.LPArray)] CLEventHandle[] event_wait_list, out CLEventHandle new_event)
 {
     return StaticEnqueueTask(command_queue, kernel, num_events_in_wait_list, event_wait_list, out new_event);
 }

 public IntPtr EnqueueMapImage(CLCommandQueueHandle command_queue, CLMemoryHandle image, [MarshalAs(UnmanagedType.Bool)] bool blocking_map, ComputeMemoryMappingFlags map_flags, ref SysIntX3 origin, ref SysIntX3 region, out IntPtr image_row_pitch, out IntPtr image_slice_pitch, Int32 num_events_in_wait_list, [MarshalAs(UnmanagedType.LPArray)] CLEventHandle[] event_wait_list, out CLEventHandle new_event, out ComputeErrorCode errcode_ret)
 {
     return StaticEnqueueMapImage(command_queue, image, blocking_map, map_flags, ref origin, ref region, out image_row_pitch, out image_slice_pitch, num_events_in_wait_list, event_wait_list, out new_event, out errcode_ret);
 }

 public IntPtr EnqueueMapBuffer(CLCommandQueueHandle command_queue, CLMemoryHandle buffer, [MarshalAs(UnmanagedType.Bool)] bool blocking_map, ComputeMemoryMappingFlags map_flags, IntPtr offset, IntPtr cb, Int32 num_events_in_wait_list, [MarshalAs(UnmanagedType.LPArray)] CLEventHandle[] event_wait_list, out CLEventHandle new_event, out ComputeErrorCode errcode_ret)
 {
     return StaticEnqueueMapBuffer(command_queue, buffer, blocking_map, map_flags, offset, cb, num_events_in_wait_list, event_wait_list, out new_event, out errcode_ret);
 }

 public ComputeErrorCode EnqueueFillImage(CLCommandQueueHandle command_queue, CLMemoryHandle image, IntPtr fill_color, ref SysIntX3 origin, ref SysIntX3 region, int num_events_in_wait_list, [MarshalAs(UnmanagedType.LPArray)] CLEventHandle[] event_wait_list, out CLEventHandle new_event)
 {
     throw new NotImplementedException();
 }

 public ComputeErrorCode EnqueueFillBuffer(CLCommandQueueHandle command_queue, CLMemoryHandle buffer, IntPtr pattern, IntPtr pattern_size, IntPtr offset, IntPtr size, int num_events_in_wait_list, [MarshalAs(UnmanagedType.LPArray)] CLEventHandle[] event_wait_list, out CLEventHandle new_event)
 {
     throw new NotImplementedException();
 }

 public ComputeErrorCode EnqueueCopyImageToBuffer(CLCommandQueueHandle command_queue, CLMemoryHandle src_image, CLMemoryHandle dst_buffer, ref SysIntX3 src_origin, ref SysIntX3 region, IntPtr dst_offset, Int32 num_events_in_wait_list, [MarshalAs(UnmanagedType.LPArray)] CLEventHandle[] event_wait_list, out CLEventHandle new_event)
 {
     return StaticEnqueueCopyImageToBuffer(command_queue, src_image, dst_buffer, ref src_origin, ref region, dst_offset, num_events_in_wait_list, event_wait_list, out new_event);
 }