source: trunk/CrypPlugins/Libs/OpenCLNet/CommandQueue.cs @ 2040

Last change on this file since 2040 was 2040, checked in by Sven Rech, 11 years ago
  • added OpenCL.Net project
  • added OpenCL settings in KeySearcher
  • changed rereservation status message behavior
File size: 161.9 KB
Line 
1/*
2 * Copyright (c) 2009 Olav Kalgraf(olav.kalgraf@gmail.com)
3 *
4 * Permission is hereby granted, free of charge, to any person
5 * obtaining a copy of this software and associated documentation
6 * files (the "Software"), to deal in the Software without
7 * restriction, including without limitation the rights to use,
8 * copy, modify, merge, publish, distribute, sublicense, and/or sell
9 * copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following
11 * conditions:
12 *
13 * The above copyright notice and this permission notice shall be
14 * included in all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
18 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
20 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
21 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
23 * OTHER DEALINGS IN THE SOFTWARE.
24 */
25
26using System;
27using System.Collections.Generic;
28using System.ComponentModel;
29using System.Runtime.InteropServices;
30using System.Runtime.InteropServices.ComTypes;
31using System.Text;
32using System.Threading;
33
34namespace OpenCLNet
35{
36    /// <summary>
37    /// The CommandQueue class wraps an OpenCL command queue reference.
38    ///
39    /// This class contains methods that correspond to all OpenCL functions that take
40    /// a command queue as their first parameter. Most notably, all the Enqueue() functions.
41    /// In effect, it makes this class into the workhorse of most OpenCL applications.
42    /// </summary>
43    unsafe public class CommandQueue : IDisposable
44    {
45        public IntPtr CommandQueueID { get; private set; }
46        public Context Context { get; private set; }
47        public Device Device { get; private set; }
48        public uint ReferenceCount { get { return 0; } }
49        public CommandQueueProperties Properties { get { return (CommandQueueProperties)0; } }
50
51        // Track whether Dispose has been called.
52        private bool disposed = false;
53
54        #region Construction / Destruction
55
56        internal CommandQueue( Context context, Device device, IntPtr commandQueueID )
57        {
58            Context = context;
59            Device = device;
60            CommandQueueID = commandQueueID;
61        }
62
63        // Use C# destructor syntax for finalization code.
64        // This destructor will run only if the Dispose method
65        // does not get called.
66        // It gives your base class the opportunity to finalize.
67        // Do not provide destructors in types derived from this class.
68        ~CommandQueue()
69        {
70            // Do not re-create Dispose clean-up code here.
71            // Calling Dispose(false) is optimal in terms of
72            // readability and maintainability.
73            Dispose( false );
74        }
75
76        #endregion
77
78        #region IDisposable Members
79
80        // Implement IDisposable.
81        // Do not make this method virtual.
82        // A derived class should not be able to override this method.
83        public void Dispose()
84        {
85            Dispose( true );
86            // This object will be cleaned up by the Dispose method.
87            // Therefore, you should call GC.SupressFinalize to
88            // take this object off the finalization queue
89            // and prevent finalization code for this object
90            // from executing a second time.
91            GC.SuppressFinalize( this );
92        }
93
94        // Dispose(bool disposing) executes in two distinct scenarios.
95        // If disposing equals true, the method has been called directly
96        // or indirectly by a user's code. Managed and unmanaged resources
97        // can be disposed.
98        // If disposing equals false, the method has been called by the
99        // runtime from inside the finalizer and you should not reference
100        // other objects. Only unmanaged resources can be disposed.
101        private void Dispose( bool disposing )
102        {
103            // Check to see if Dispose has already been called.
104            if( !this.disposed )
105            {
106                // If disposing equals true, dispose all managed
107                // and unmanaged resources.
108                if( disposing )
109                {
110                    // Dispose managed resources.
111                }
112
113                // Call the appropriate methods to clean up
114                // unmanaged resources here.
115                // If disposing is false,
116                // only the following code is executed.
117                OpenCL.ReleaseCommandQueue( CommandQueueID );
118                CommandQueueID = IntPtr.Zero;
119
120                // Note disposing has been done.
121                disposed = true;
122            }
123        }
124
125        #endregion
126
127        // Enqueue methods follow. Typically, each will have 3 versions.
128        // One which takes an event wait list and and event output
129        // One which takes an event wait list
130        // and one which takes neither
131        // There are also overloads which take int, long and IntPtr arguments
132
133        #region EnqueueWriteBuffer
134
135        /// <summary>
136        /// Enqueues a command to write data to a buffer object identified by buffer from host memory identified by ptr.
137        /// </summary>
138        /// <param name="buffer"></param>
139        /// <param name="blockingWrite"></param>
140        /// <param name="offset"></param>
141        /// <param name="cb"></param>
142        /// <param name="ptr"></param>
143        /// <param name="event_wait_list"></param>
144        /// <param name="InteropTools.ConvertEventsToEventIDs(event_wait_list)"></param>
145        /// <param name="_event"></param>
146        public void EnqueueWriteBuffer(Mem buffer, bool blockingWrite, IntPtr offset, IntPtr cb, IntPtr ptr, int numEventsInWaitList, Event[] event_wait_list, out Event _event)
147        {
148            ErrorCode result;
149            IntPtr tmpEvent;
150
151            result = OpenCL.EnqueueWriteBuffer(CommandQueueID,
152                buffer.MemID,
153                (uint)(blockingWrite ? Bool.TRUE : Bool.FALSE),
154                offset,
155                cb,
156                ptr.ToPointer(),
157                (uint)numEventsInWaitList,
158                InteropTools.ConvertEventsToEventIDs(event_wait_list),
159                &tmpEvent);
160            _event = new Event( Context, this, tmpEvent );
161            if (result != ErrorCode.SUCCESS)
162                throw new OpenCLException("EnqueueWriteBuffer failed with error code " + result, result);
163        }
164        public void EnqueueWriteBuffer(Mem buffer, bool blockingWrite, int offset, int cb, IntPtr ptr, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
165        {
166            ErrorCode result;
167            IntPtr tmpEvent;
168            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
169
170            if (num_events_in_wait_list == 0)
171                repackedEvents = null;
172            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
173            result = OpenCL.EnqueueWriteBuffer(CommandQueueID,
174                buffer,
175                (uint)(blockingWrite ? Bool.TRUE : Bool.FALSE),
176                offset,
177                cb,
178                ptr,
179                num_events_in_wait_list,
180                repackedEvents,
181                &tmpEvent);
182            _event = new Event(Context, this, tmpEvent);
183            if (result != ErrorCode.SUCCESS)
184                throw new OpenCLException("EnqueueWriteBuffer failed with error code " + result, result);
185        }
186        public void EnqueueWriteBuffer(Mem buffer, bool blockingWrite, long offset, long cb, IntPtr ptr, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
187        {
188            ErrorCode result;
189            IntPtr tmpEvent;
190            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
191
192            if (num_events_in_wait_list == 0)
193                repackedEvents = null;
194            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
195            result = OpenCL.EnqueueWriteBuffer(CommandQueueID,
196                buffer,
197                (uint)(blockingWrite ? Bool.TRUE : Bool.FALSE),
198                offset,
199                cb,
200                ptr,
201                num_events_in_wait_list,
202                repackedEvents,
203                &tmpEvent);
204            _event = new Event(Context, this, tmpEvent);
205            if (result != ErrorCode.SUCCESS)
206                throw new OpenCLException("EnqueueWriteBuffer failed with error code " + result, result);
207        }
208
209        public void EnqueueWriteBuffer(Mem buffer, bool blockingWrite, IntPtr offset, IntPtr cb, IntPtr ptr, int num_events_in_wait_list, Event[] event_wait_list)
210        {
211            ErrorCode result;
212
213            result = OpenCL.EnqueueWriteBuffer(CommandQueueID,
214                buffer.MemID,
215                (uint)(blockingWrite ? Bool.TRUE : Bool.FALSE),
216                offset,
217                cb,
218                ptr.ToPointer(),
219                (uint)num_events_in_wait_list,
220                InteropTools.ConvertEventsToEventIDs(event_wait_list),
221                null);
222            if (result != ErrorCode.SUCCESS)
223                throw new OpenCLException("EnqueueWriteBuffer failed with error code " + result, result);
224        }
225        public void EnqueueWriteBuffer(Mem buffer, bool blockingWrite, int offset, int cb, IntPtr ptr, int num_events_in_wait_list, Event[] event_wait_list)
226        {
227            ErrorCode result;
228            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
229
230            if (num_events_in_wait_list == 0)
231                repackedEvents = null;
232            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
233            result = OpenCL.EnqueueWriteBuffer(CommandQueueID,
234                buffer,
235                (uint)(blockingWrite ? Bool.TRUE : Bool.FALSE),
236                offset,
237                cb,
238                ptr,
239                num_events_in_wait_list,
240                repackedEvents,
241                null);
242            if (result != ErrorCode.SUCCESS)
243                throw new OpenCLException("EnqueueWriteBuffer failed with error code " + result, result);
244        }
245        public void EnqueueWriteBuffer(Mem buffer, bool blockingWrite, long offset, long cb, IntPtr ptr, int num_events_in_wait_list, Event[] event_wait_list)
246        {
247            ErrorCode result;
248            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
249
250            if (num_events_in_wait_list == 0)
251                repackedEvents = null;
252            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
253            result = OpenCL.EnqueueWriteBuffer(CommandQueueID,
254                buffer,
255                (uint)(blockingWrite ? Bool.TRUE : Bool.FALSE),
256                offset,
257                cb,
258                ptr,
259                num_events_in_wait_list,
260                repackedEvents,
261                null);
262            if (result != ErrorCode.SUCCESS)
263                throw new OpenCLException("EnqueueWriteBuffer failed with error code " + result, result);
264        }
265
266        public void EnqueueWriteBuffer(Mem buffer, bool blockingWrite, IntPtr offset, IntPtr cb, IntPtr ptr)
267        {
268            ErrorCode result;
269
270            result = OpenCL.EnqueueWriteBuffer(CommandQueueID,
271                buffer.MemID,
272                (uint)(blockingWrite ? Bool.TRUE : Bool.FALSE),
273                offset,
274                cb,
275                ptr.ToPointer(),
276                (uint)0,
277                null,
278                null);
279            if (result != ErrorCode.SUCCESS)
280                throw new OpenCLException("EnqueueReadBuffer failed with error code " + result, result);
281        }
282        public void EnqueueWriteBuffer(Mem buffer, bool blockingWrite, int offset, int cb, IntPtr ptr)
283        {
284            ErrorCode result;
285
286            result = OpenCL.EnqueueWriteBuffer(CommandQueueID,
287                buffer,
288                (uint)(blockingWrite ? Bool.TRUE : Bool.FALSE),
289                offset,
290                cb,
291                ptr,
292                0,
293                null,
294                null);
295            if (result != ErrorCode.SUCCESS)
296                throw new OpenCLException("EnqueueWriteBuffer failed with error code " + result, result);
297        }
298        public void EnqueueWriteBuffer(Mem buffer, bool blockingWrite, long offset, long cb, IntPtr ptr)
299        {
300            ErrorCode result;
301
302            result = OpenCL.EnqueueWriteBuffer(CommandQueueID,
303                buffer,
304                (uint)(blockingWrite ? Bool.TRUE : Bool.FALSE),
305                offset,
306                cb,
307                ptr,
308                0,
309                null,
310                null);
311            if (result != ErrorCode.SUCCESS)
312                throw new OpenCLException("EnqueueWriteBuffer failed with error code " + result, result);
313        }
314
315        #endregion
316
317        #region EnqueueReadBuffer
318
319        /// <summary>
320        /// Enqueues a command to read data from a buffer object identified by buffer to host memory identified by ptr.
321        /// </summary>
322        /// <param name="buffer"></param>
323        /// <param name="blockingRead"></param>
324        /// <param name="offset"></param>
325        /// <param name="cb"></param>
326        /// <param name="ptr"></param>
327        /// <param name="numEventsInWaitList"></param>
328        /// <param name="event_wait_list"></param>
329        /// <param name="_event"></param>
330        public void EnqueueReadBuffer(Mem buffer, bool blockingRead, IntPtr offset, IntPtr cb, IntPtr ptr, int numEventsInWaitList, Event[] event_wait_list, out Event _event)
331        {
332            ErrorCode result;
333            IntPtr tmpEvent;
334
335            result = OpenCL.EnqueueReadBuffer(CommandQueueID,
336                buffer.MemID,
337                (uint)(blockingRead ? Bool.TRUE : Bool.FALSE),
338                offset,
339                cb,
340                ptr.ToPointer(),
341                (uint)numEventsInWaitList,
342                InteropTools.ConvertEventsToEventIDs(event_wait_list),
343                &tmpEvent);
344            _event = new Event(Context, this, tmpEvent); 
345            if (result != ErrorCode.SUCCESS)
346                throw new OpenCLException("EnqueueReadBuffer failed with error code " + result, result);
347        }
348        public void EnqueueReadBuffer(Mem buffer, bool blockingRead, int offset, int cb, IntPtr ptr, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
349        {
350            ErrorCode result;
351            IntPtr tmpEvent;
352            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
353
354            if (num_events_in_wait_list == 0)
355                repackedEvents = null;
356            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
357            result = OpenCL.EnqueueReadBuffer(CommandQueueID,
358                buffer,
359                (uint)(blockingRead ? Bool.TRUE : Bool.FALSE),
360                offset,
361                cb,
362                ptr,
363                num_events_in_wait_list,
364                repackedEvents,
365                &tmpEvent);
366            _event = new Event(Context, this, tmpEvent);
367            if (result != ErrorCode.SUCCESS)
368                throw new OpenCLException("EnqueueReadBuffer failed with error code " + result, result);
369        }
370        public void EnqueueReadBuffer(Mem buffer, bool blockingRead, long offset, long cb, IntPtr ptr, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
371        {
372            ErrorCode result;
373            IntPtr tmpEvent;
374            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
375
376            if (num_events_in_wait_list == 0)
377                repackedEvents = null;
378            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
379            result = OpenCL.EnqueueReadBuffer(CommandQueueID,
380                buffer,
381                (uint)(blockingRead ? Bool.TRUE : Bool.FALSE),
382                offset,
383                cb,
384                ptr,
385                num_events_in_wait_list,
386                repackedEvents,
387                &tmpEvent);
388            _event = new Event(Context, this, tmpEvent);
389            if (result != ErrorCode.SUCCESS)
390                throw new OpenCLException("EnqueueReadBuffer failed with error code " + result, result);
391        }
392
393        public void EnqueueReadBuffer(Mem buffer, bool blockingRead, IntPtr offset, IntPtr cb, IntPtr ptr, int num_events_in_wait_list, Event[] event_wait_list)
394        {
395            ErrorCode result;
396
397            result = OpenCL.EnqueueReadBuffer(CommandQueueID,
398                buffer.MemID,
399                (uint)(blockingRead ? Bool.TRUE : Bool.FALSE),
400                offset,
401                cb,
402                ptr.ToPointer(),
403                (uint)num_events_in_wait_list,
404                InteropTools.ConvertEventsToEventIDs(event_wait_list),
405                null);
406            if (result != ErrorCode.SUCCESS)
407                throw new OpenCLException("EnqueueReadBuffer failed with error code " + result, result);
408        }
409        public void EnqueueReadBuffer(Mem buffer, bool blockingRead, int offset, int cb, IntPtr ptr, int num_events_in_wait_list, Event[] event_wait_list)
410        {
411            ErrorCode result;
412            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
413
414            if (num_events_in_wait_list == 0)
415                repackedEvents = null;
416            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
417            result = OpenCL.EnqueueReadBuffer(CommandQueueID,
418                buffer,
419                (uint)(blockingRead ? Bool.TRUE : Bool.FALSE),
420                offset,
421                cb,
422                ptr,
423                num_events_in_wait_list,
424                repackedEvents,
425                null);
426            if (result != ErrorCode.SUCCESS)
427                throw new OpenCLException("EnqueueReadBuffer failed with error code " + result, result);
428        }
429        public void EnqueueReadBuffer(Mem buffer, bool blockingRead, long offset, long cb, IntPtr ptr, int num_events_in_wait_list, Event[] event_wait_list)
430        {
431            ErrorCode result;
432            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
433
434            if (num_events_in_wait_list == 0)
435                repackedEvents = null;
436            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
437            result = OpenCL.EnqueueReadBuffer(CommandQueueID,
438                buffer,
439                (uint)(blockingRead ? Bool.TRUE : Bool.FALSE),
440                offset,
441                cb,
442                ptr,
443                num_events_in_wait_list,
444                repackedEvents,
445                null);
446            if (result != ErrorCode.SUCCESS)
447                throw new OpenCLException("EnqueueReadBuffer failed with error code " + result, result);
448        }
449
450        public void EnqueueReadBuffer(Mem buffer, bool blockingRead, IntPtr offset, IntPtr cb, IntPtr ptr)
451        {
452            ErrorCode result;
453
454            result = OpenCL.EnqueueReadBuffer(CommandQueueID,
455                buffer.MemID,
456                (uint)(blockingRead ? Bool.TRUE : Bool.FALSE),
457                offset,
458                cb,
459                ptr.ToPointer(),
460                (uint)0,
461                null,
462                null);
463            if (result != ErrorCode.SUCCESS)
464                throw new OpenCLException("EnqueueReadBuffer failed with error code " + result, result);
465        }
466        public void EnqueueReadBuffer(Mem buffer, bool blockingRead, int offset, int cb, IntPtr ptr)
467        {
468            ErrorCode result;
469
470            result = OpenCL.EnqueueReadBuffer(CommandQueueID,
471                buffer,
472                (uint)(blockingRead ? Bool.TRUE : Bool.FALSE),
473                offset,
474                cb,
475                ptr,
476                0,
477                null,
478                null);
479            if (result != ErrorCode.SUCCESS)
480                throw new OpenCLException("EnqueueReadBuffer failed with error code " + result, result);
481        }
482        public void EnqueueReadBuffer(Mem buffer, bool blockingRead, long offset, long cb, IntPtr ptr)
483        {
484            ErrorCode result;
485
486            result = OpenCL.EnqueueReadBuffer(CommandQueueID,
487                buffer,
488                (uint)(blockingRead ? Bool.TRUE : Bool.FALSE),
489                offset,
490                cb,
491                ptr,
492                0,
493                null,
494                null);
495            if (result != ErrorCode.SUCCESS)
496                throw new OpenCLException("EnqueueReadBuffer failed with error code " + result, result);
497        }
498
499        #endregion
500
501        #region EnqueueCopyBuffer
502
503        /// <summary>
504        /// Enqueues a command to copy a buffer object identified by src_buffer to another buffer object identified by dst_buffer.
505        /// </summary>
506        /// <param name="src_buffer"></param>
507        /// <param name="dst_buffer"></param>
508        /// <param name="src_offset"></param>
509        /// <param name="dst_offset"></param>
510        /// <param name="cb"></param>
511        /// <param name="num_events_in_wait_list"></param>
512        /// <param name="event_wait_list"></param>
513        /// <param name="_event"></param>
514        public void EnqueueCopyBuffer(Mem src_buffer, Mem dst_buffer, IntPtr src_offset, IntPtr dst_offset, IntPtr cb, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
515        {
516            ErrorCode result;
517            IntPtr tmpEvent;
518
519            result = OpenCL.EnqueueCopyBuffer(CommandQueueID,
520                src_buffer.MemID,
521                dst_buffer.MemID,
522                src_offset,
523                dst_offset,
524                cb,
525                (uint)num_events_in_wait_list,
526                InteropTools.ConvertEventsToEventIDs(event_wait_list),
527                &tmpEvent);
528            _event = new Event(Context, this, tmpEvent);
529            if (result != ErrorCode.SUCCESS)
530                throw new OpenCLException("EnqueueCopyBuffer failed with error code " + result, result);
531        }
532        public void EnqueueCopyBuffer(Mem src_buffer, Mem dst_buffer, int src_offset, int dst_offset, int cb, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
533        {
534            EnqueueCopyBuffer(src_buffer, dst_buffer, (IntPtr)src_offset, (IntPtr)dst_offset, (IntPtr)cb, num_events_in_wait_list, event_wait_list, out _event);
535        }
536        public void EnqueueCopyBuffer(Mem src_buffer, Mem dst_buffer, long src_offset, long dst_offset, long cb, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
537        {
538            EnqueueCopyBuffer(src_buffer, dst_buffer, (IntPtr)src_offset, (IntPtr)dst_offset, (IntPtr)cb, num_events_in_wait_list, event_wait_list, out _event);
539        }
540
541        public void EnqueueCopyBuffer(Mem src_buffer, Mem dst_buffer, IntPtr src_offset, IntPtr dst_offset, IntPtr cb, int num_events_in_wait_list, Event[] event_wait_list)
542        {
543            ErrorCode result;
544
545            result = OpenCL.EnqueueCopyBuffer(CommandQueueID,
546                src_buffer.MemID,
547                dst_buffer.MemID,
548                src_offset,
549                dst_offset,
550                cb,
551                (uint)num_events_in_wait_list,
552                InteropTools.ConvertEventsToEventIDs(event_wait_list),
553                null);
554            if (result != ErrorCode.SUCCESS)
555                throw new OpenCLException("EnqueueCopyBuffer failed with error code " + result, result);
556        }
557        public void EnqueueCopyBuffer(Mem src_buffer, Mem dst_buffer, int src_offset, int dst_offset, int cb, int num_events_in_wait_list, Event[] event_wait_list)
558        {
559            EnqueueCopyBuffer(src_buffer, dst_buffer, (IntPtr)src_offset, (IntPtr)dst_offset, (IntPtr)cb, num_events_in_wait_list, event_wait_list);
560        }
561        public void EnqueueCopyBuffer(Mem src_buffer, Mem dst_buffer, long src_offset, long dst_offset, long cb, int num_events_in_wait_list, Event[] event_wait_list)
562        {
563            EnqueueCopyBuffer(src_buffer, dst_buffer, (IntPtr)src_offset, (IntPtr)dst_offset, (IntPtr)cb, num_events_in_wait_list, event_wait_list);
564        }
565
566        public void EnqueueCopyBuffer(Mem src_buffer, Mem dst_buffer, IntPtr src_offset, IntPtr dst_offset, IntPtr cb)
567        {
568            ErrorCode result;
569
570            result = OpenCL.EnqueueCopyBuffer(CommandQueueID,
571                src_buffer.MemID,
572                dst_buffer.MemID,
573                src_offset,
574                dst_offset,
575                cb,
576                (uint)0,
577                null,
578                null);
579            if (result != ErrorCode.SUCCESS)
580                throw new OpenCLException("EnqueueCopyBuffer failed with error code " + result, result);
581        }
582        public void EnqueueCopyBuffer(Mem src_buffer, Mem dst_buffer, int src_offset, int dst_offset, int cb)
583        {
584            EnqueueCopyBuffer(src_buffer, dst_buffer, (IntPtr)src_offset, (IntPtr)dst_offset, (IntPtr)cb);
585        }
586        public void EnqueueCopyBuffer(Mem src_buffer, Mem dst_buffer, long src_offset, long dst_offset, long cb)
587        {
588            EnqueueCopyBuffer(src_buffer, dst_buffer, (IntPtr)src_offset, (IntPtr)dst_offset, (IntPtr)cb);
589        }
590
591        #endregion
592
593        #region EnqueueReadImage
594
595        public void EnqueueReadImage(Mem image, bool blockingRead, IntPtr[] origin, IntPtr[] region, IntPtr row_pitch, IntPtr slice_pitch, IntPtr ptr, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
596        {
597            ErrorCode result;
598            IntPtr tmpEvent;
599
600            result = OpenCL.EnqueueReadImage(CommandQueueID,
601                image.MemID,
602                (uint)(blockingRead ? Bool.TRUE : Bool.FALSE),
603                origin,
604                region,
605                row_pitch,
606                slice_pitch,
607                ptr.ToPointer(),
608                (uint)num_events_in_wait_list,
609                InteropTools.ConvertEventsToEventIDs(event_wait_list),
610                &tmpEvent);
611            _event = new Event(Context, this, tmpEvent);
612            if (result != ErrorCode.SUCCESS)
613                throw new OpenCLException("EnqueueReadImage failed with error code " + result, result);
614        }
615        public void EnqueueReadImage(Mem image, bool blockingRead, int[] origin, int[] region, int row_pitch, int slice_pitch, IntPtr ptr, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
616        {
617            ErrorCode result;
618            IntPtr tmpEvent;
619            IntPtr* repackedOrigin = stackalloc IntPtr[3];
620            IntPtr* repackedRegion = stackalloc IntPtr[3];
621            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
622
623            if (num_events_in_wait_list == 0)
624                repackedEvents = null;
625            InteropTools.A3ToIntPtr3(origin, repackedOrigin);
626            InteropTools.A3ToIntPtr3(region, repackedRegion);
627            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
628
629            result = OpenCL.EnqueueReadImage(CommandQueueID,
630                image.MemID,
631                (uint)(blockingRead ? Bool.TRUE : Bool.FALSE),
632                repackedOrigin,
633                repackedRegion,
634                row_pitch,
635                slice_pitch,
636                ptr,
637                num_events_in_wait_list,
638                repackedEvents,
639                &tmpEvent);
640            _event = new Event(Context, this, tmpEvent);
641            if (result != ErrorCode.SUCCESS)
642                throw new OpenCLException("EnqueueReadImage failed with error code " + result, result);
643        }
644        public void EnqueueReadImage(Mem image, bool blockingRead, long[] origin, long[] region, long row_pitch, long slice_pitch, IntPtr ptr, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
645        {
646            ErrorCode result;
647            IntPtr tmpEvent;
648            IntPtr* repackedOrigin = stackalloc IntPtr[3];
649            IntPtr* repackedRegion = stackalloc IntPtr[3];
650            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
651
652            if (num_events_in_wait_list == 0)
653                repackedEvents = null;
654            InteropTools.A3ToIntPtr3(origin, repackedOrigin);
655            InteropTools.A3ToIntPtr3(region, repackedRegion);
656            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
657
658            result = OpenCL.EnqueueReadImage(CommandQueueID,
659                image.MemID,
660                (uint)(blockingRead ? Bool.TRUE : Bool.FALSE),
661                repackedOrigin,
662                repackedRegion,
663                row_pitch,
664                slice_pitch,
665                ptr,
666                num_events_in_wait_list,
667                repackedEvents,
668                &tmpEvent);
669            _event = new Event(Context, this, tmpEvent);
670            if (result != ErrorCode.SUCCESS)
671                throw new OpenCLException("EnqueueReadImage failed with error code " + result, result);
672        }
673
674        public void EnqueueReadImage(Mem image, bool blockingRead, IntPtr[] origin, IntPtr[] region, IntPtr row_pitch, IntPtr slice_pitch, IntPtr ptr, int num_events_in_wait_list, Event[] event_wait_list)
675        {
676            ErrorCode result;
677
678            result = OpenCL.EnqueueReadImage(CommandQueueID,
679                image.MemID,
680                (uint)(blockingRead ? Bool.TRUE : Bool.FALSE),
681                origin,
682                region,
683                row_pitch,
684                slice_pitch,
685                ptr.ToPointer(),
686                (uint)num_events_in_wait_list,
687                InteropTools.ConvertEventsToEventIDs(event_wait_list),
688                null);
689            if (result != ErrorCode.SUCCESS)
690                throw new OpenCLException("EnqueueReadImage failed with error code " + result, result);
691        }
692        public void EnqueueReadImage(Mem image, bool blockingRead, int[] origin, int[] region, int row_pitch, int slice_pitch, IntPtr ptr, int num_events_in_wait_list, Event[] event_wait_list)
693        {
694            ErrorCode result;
695            IntPtr* repackedOrigin = stackalloc IntPtr[3];
696            IntPtr* repackedRegion = stackalloc IntPtr[3];
697            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
698
699            if (num_events_in_wait_list == 0)
700                repackedEvents = null;
701            InteropTools.A3ToIntPtr3(origin, repackedOrigin);
702            InteropTools.A3ToIntPtr3(region, repackedRegion);
703            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
704
705            result = OpenCL.EnqueueReadImage(CommandQueueID,
706                image.MemID,
707                (uint)(blockingRead ? Bool.TRUE : Bool.FALSE),
708                repackedOrigin,
709                repackedRegion,
710                row_pitch,
711                slice_pitch,
712                ptr,
713                num_events_in_wait_list,
714                repackedEvents,
715                null);
716            if (result != ErrorCode.SUCCESS)
717                throw new OpenCLException("EnqueueReadImage failed with error code " + result, result);
718        }
719        public void EnqueueReadImage(Mem image, bool blockingRead, long[] origin, long[] region, long row_pitch, long slice_pitch, IntPtr ptr, int num_events_in_wait_list, Event[] event_wait_list)
720        {
721            ErrorCode result;
722            IntPtr* repackedOrigin = stackalloc IntPtr[3];
723            IntPtr* repackedRegion = stackalloc IntPtr[3];
724            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
725
726            if (num_events_in_wait_list == 0)
727                repackedEvents = null;
728            InteropTools.A3ToIntPtr3(origin, repackedOrigin);
729            InteropTools.A3ToIntPtr3(region, repackedRegion);
730            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
731
732            result = OpenCL.EnqueueReadImage(CommandQueueID,
733                image.MemID,
734                (uint)(blockingRead ? Bool.TRUE : Bool.FALSE),
735                repackedOrigin,
736                repackedRegion,
737                row_pitch,
738                slice_pitch,
739                ptr,
740                num_events_in_wait_list,
741                repackedEvents,
742                null);
743            if (result != ErrorCode.SUCCESS)
744                throw new OpenCLException("EnqueueReadImage failed with error code " + result, result);
745        }
746
747        public void EnqueueReadImage(Mem image, bool blockingRead, IntPtr[] origin, IntPtr[] region, IntPtr row_pitch, IntPtr slice_pitch, IntPtr ptr)
748        {
749            ErrorCode result;
750
751            result = OpenCL.EnqueueReadImage(CommandQueueID,
752                image.MemID,
753                (uint)(blockingRead ? Bool.TRUE : Bool.FALSE),
754                origin,
755                region,
756                row_pitch,
757                slice_pitch,
758                ptr.ToPointer(),
759                (uint)0,
760                null,
761                null);
762            if (result != ErrorCode.SUCCESS)
763                throw new OpenCLException("EnqueueReadImage failed with error code " + result, result);
764        }
765        public void EnqueueReadImage(Mem image, bool blockingRead, int[] origin, int[] region, int row_pitch, int slice_pitch, IntPtr ptr)
766        {
767            ErrorCode result;
768            IntPtr* repackedOrigin = stackalloc IntPtr[3];
769            IntPtr* repackedRegion = stackalloc IntPtr[3];
770
771            InteropTools.A3ToIntPtr3(origin, repackedOrigin);
772            InteropTools.A3ToIntPtr3(region, repackedRegion);
773
774            result = OpenCL.EnqueueReadImage(CommandQueueID,
775                image.MemID,
776                (uint)(blockingRead ? Bool.TRUE : Bool.FALSE),
777                repackedOrigin,
778                repackedRegion,
779                row_pitch,
780                slice_pitch,
781                ptr,
782                0,
783                null,
784                null);
785            if (result != ErrorCode.SUCCESS)
786                throw new OpenCLException("EnqueueReadImage failed with error code " + result, result);
787        }
788        public void EnqueueReadImage(Mem image, bool blockingRead, long[] origin, long[] region, long row_pitch, long slice_pitch, IntPtr ptr)
789        {
790            ErrorCode result;
791            IntPtr* repackedOrigin = stackalloc IntPtr[3];
792            IntPtr* repackedRegion = stackalloc IntPtr[3];
793
794            InteropTools.A3ToIntPtr3(origin, repackedOrigin);
795            InteropTools.A3ToIntPtr3(region, repackedRegion);
796
797            result = OpenCL.EnqueueReadImage(CommandQueueID,
798                image.MemID,
799                (uint)(blockingRead ? Bool.TRUE : Bool.FALSE),
800                repackedOrigin,
801                repackedRegion,
802                row_pitch,
803                slice_pitch,
804                ptr,
805                0,
806                null,
807                null);
808            if (result != ErrorCode.SUCCESS)
809                throw new OpenCLException("EnqueueReadImage failed with error code " + result, result);
810        }
811
812        #endregion
813
814        #region EnqueueWriteImage
815
816        public void EnqueueWriteImage(Mem image, bool blockingWrite, IntPtr[] origin, IntPtr[] region, IntPtr input_row_pitch, IntPtr input_slice_pitch, IntPtr ptr, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
817        {
818            ErrorCode result;
819            IntPtr tmpEvent;
820
821            result = OpenCL.EnqueueWriteImage(CommandQueueID,
822                image.MemID,
823                (uint)(blockingWrite ? Bool.TRUE : Bool.FALSE),
824                origin,
825                region,
826                input_row_pitch,
827                input_slice_pitch,
828                ptr.ToPointer(),
829                (uint)num_events_in_wait_list,
830                InteropTools.ConvertEventsToEventIDs(event_wait_list),
831                &tmpEvent);
832            _event = new Event(Context, this, tmpEvent);
833            if (result != ErrorCode.SUCCESS)
834                throw new OpenCLException("EnqueueWriteImage failed with error code " + result, result);
835        }
836        public void EnqueueWriteImage(Mem image, bool blockingWrite, int[] origin, int[] region, int input_row_pitch, int input_slice_pitch, IntPtr ptr, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
837        {
838            ErrorCode result;
839            IntPtr tmpEvent;
840            IntPtr* repackedOrigin = stackalloc IntPtr[3];
841            IntPtr* repackedRegion = stackalloc IntPtr[3];
842            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
843
844            if (num_events_in_wait_list == 0)
845                repackedEvents = null;
846            InteropTools.A3ToIntPtr3(origin, repackedOrigin);
847            InteropTools.A3ToIntPtr3(region, repackedRegion);
848            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
849
850            result = OpenCL.EnqueueWriteImage(CommandQueueID,
851                image.MemID,
852                (uint)(blockingWrite ? Bool.TRUE : Bool.FALSE),
853                repackedOrigin,
854                repackedRegion,
855                input_row_pitch,
856                input_slice_pitch,
857                ptr,
858                num_events_in_wait_list,
859                repackedEvents,
860                &tmpEvent);
861            _event = new Event(Context, this, tmpEvent);
862            if (result != ErrorCode.SUCCESS)
863                throw new OpenCLException("EnqueueWriteImage failed with error code " + result, result);
864        }
865        public void EnqueueWriteImage(Mem image, bool blockingWrite, long[] origin, long[] region, long input_row_pitch, long input_slice_pitch, IntPtr ptr, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
866        {
867            ErrorCode result;
868            IntPtr tmpEvent;
869            IntPtr* repackedOrigin = stackalloc IntPtr[3];
870            IntPtr* repackedRegion = stackalloc IntPtr[3];
871            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
872
873            if (num_events_in_wait_list == 0)
874                repackedEvents = null;
875            InteropTools.A3ToIntPtr3(origin, repackedOrigin);
876            InteropTools.A3ToIntPtr3(region, repackedRegion);
877            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
878
879            result = OpenCL.EnqueueWriteImage(CommandQueueID,
880                image.MemID,
881                (uint)(blockingWrite ? Bool.TRUE : Bool.FALSE),
882                repackedOrigin,
883                repackedRegion,
884                input_row_pitch,
885                input_slice_pitch,
886                ptr,
887                num_events_in_wait_list,
888                repackedEvents,
889                &tmpEvent);
890            _event = new Event(Context, this, tmpEvent);
891            if (result != ErrorCode.SUCCESS)
892                throw new OpenCLException("EnqueueWriteImage failed with error code " + result, result);
893        }
894
895        public void EnqueueWriteImage(Mem image, bool blockingWrite, IntPtr[] origin, IntPtr[] region, IntPtr input_row_pitch, IntPtr input_slice_pitch, IntPtr ptr, int num_events_in_wait_list, Event[] event_wait_list)
896        {
897            ErrorCode result;
898
899            result = OpenCL.EnqueueWriteImage(CommandQueueID,
900                image.MemID,
901                (uint)(blockingWrite ? Bool.TRUE : Bool.FALSE),
902                origin,
903                region,
904                input_row_pitch,
905                input_slice_pitch,
906                ptr.ToPointer(),
907                (uint)num_events_in_wait_list,
908                InteropTools.ConvertEventsToEventIDs(event_wait_list),
909                null);
910            if (result != ErrorCode.SUCCESS)
911                throw new OpenCLException("EnqueueWriteImage failed with error code " + result, result);
912        }
913        public void EnqueueWriteImage(Mem image, bool blockingWrite, int[] origin, int[] region, int input_row_pitch, int input_slice_pitch, IntPtr ptr, int num_events_in_wait_list, Event[] event_wait_list)
914        {
915            ErrorCode result;
916            IntPtr* repackedOrigin = stackalloc IntPtr[3];
917            IntPtr* repackedRegion = stackalloc IntPtr[3];
918            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
919
920            if (num_events_in_wait_list == 0)
921                repackedEvents = null;
922            InteropTools.A3ToIntPtr3(origin, repackedOrigin);
923            InteropTools.A3ToIntPtr3(region, repackedRegion);
924            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
925
926            result = OpenCL.EnqueueWriteImage(CommandQueueID,
927                image.MemID,
928                (uint)(blockingWrite ? Bool.TRUE : Bool.FALSE),
929                repackedOrigin,
930                repackedRegion,
931                input_row_pitch,
932                input_slice_pitch,
933                ptr,
934                num_events_in_wait_list,
935                repackedEvents,
936                null);
937            if (result != ErrorCode.SUCCESS)
938                throw new OpenCLException("EnqueueWriteImage failed with error code " + result, result);
939        }
940        public void EnqueueWriteImage(Mem image, bool blockingWrite, long[] origin, long[] region, long input_row_pitch, long input_slice_pitch, IntPtr ptr, int num_events_in_wait_list, Event[] event_wait_list)
941        {
942            ErrorCode result;
943            IntPtr* repackedOrigin = stackalloc IntPtr[3];
944            IntPtr* repackedRegion = stackalloc IntPtr[3];
945            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
946
947            if (num_events_in_wait_list == 0)
948                repackedEvents = null;
949            InteropTools.A3ToIntPtr3(origin, repackedOrigin);
950            InteropTools.A3ToIntPtr3(region, repackedRegion);
951            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
952
953            result = OpenCL.EnqueueWriteImage(CommandQueueID,
954                image.MemID,
955                (uint)(blockingWrite ? Bool.TRUE : Bool.FALSE),
956                repackedOrigin,
957                repackedRegion,
958                input_row_pitch,
959                input_slice_pitch,
960                ptr,
961                num_events_in_wait_list,
962                repackedEvents,
963                null);
964            if (result != ErrorCode.SUCCESS)
965                throw new OpenCLException("EnqueueWriteImage failed with error code " + result, result);
966        }
967
968        public void EnqueueWriteImage(Mem image, bool blockingWrite, IntPtr[] origin, IntPtr[] region, IntPtr input_row_pitch, IntPtr input_slice_pitch, IntPtr ptr)
969        {
970            ErrorCode result;
971
972            result = OpenCL.EnqueueWriteImage(CommandQueueID,
973                image.MemID,
974                (uint)(blockingWrite ? Bool.TRUE : Bool.FALSE),
975                origin,
976                region,
977                input_row_pitch,
978                input_slice_pitch,
979                ptr.ToPointer(),
980                (uint)0,
981                null,
982                null);
983            if (result != ErrorCode.SUCCESS)
984                throw new OpenCLException("EnqueueWriteImage failed with error code " + result, result);
985        }
986        public void EnqueueWriteImage(Mem image, bool blockingWrite, int[] origin, int[] region, int input_row_pitch, int input_slice_pitch, IntPtr ptr)
987        {
988            ErrorCode result;
989            IntPtr* repackedOrigin = stackalloc IntPtr[3];
990            IntPtr* repackedRegion = stackalloc IntPtr[3];
991
992            InteropTools.A3ToIntPtr3(origin, repackedOrigin);
993            InteropTools.A3ToIntPtr3(region, repackedRegion);
994
995            result = OpenCL.EnqueueWriteImage(CommandQueueID,
996                image.MemID,
997                (uint)(blockingWrite ? Bool.TRUE : Bool.FALSE),
998                repackedOrigin,
999                repackedRegion,
1000                input_row_pitch,
1001                input_slice_pitch,
1002                ptr,
1003                0,
1004                null,
1005                null);
1006            if (result != ErrorCode.SUCCESS)
1007                throw new OpenCLException("EnqueueWriteImage failed with error code " + result, result);
1008        }
1009        public void EnqueueWriteImage(Mem image, bool blockingWrite, long[] origin, long[] region, long input_row_pitch, long input_slice_pitch, IntPtr ptr)
1010        {
1011            ErrorCode result;
1012            IntPtr* repackedOrigin = stackalloc IntPtr[3];
1013            IntPtr* repackedRegion = stackalloc IntPtr[3];
1014
1015            InteropTools.A3ToIntPtr3(origin, repackedOrigin);
1016            InteropTools.A3ToIntPtr3(region, repackedRegion);
1017
1018            result = OpenCL.EnqueueWriteImage(CommandQueueID,
1019                image.MemID,
1020                (uint)(blockingWrite ? Bool.TRUE : Bool.FALSE),
1021                repackedOrigin,
1022                repackedRegion,
1023                input_row_pitch,
1024                input_slice_pitch,
1025                ptr,
1026                0,
1027                null,
1028                null);
1029            if (result != ErrorCode.SUCCESS)
1030                throw new OpenCLException("EnqueueWriteImage failed with error code " + result, result);
1031        }
1032
1033        #endregion
1034
1035        #region EnqueueCopyImage
1036
1037        public void EnqueueCopyImage(Mem src_image, Mem dst_image, IntPtr[] src_origin, IntPtr[] dst_origin, IntPtr[] region, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
1038        {
1039            ErrorCode result;
1040            IntPtr tmpEvent;
1041
1042            result = OpenCL.EnqueueCopyImage(CommandQueueID,
1043                src_image.MemID,
1044                dst_image.MemID,
1045                src_origin,
1046                dst_origin,
1047                region,
1048                (uint)num_events_in_wait_list,
1049                InteropTools.ConvertEventsToEventIDs(event_wait_list),
1050                &tmpEvent);
1051            _event = new Event(Context, this, tmpEvent);
1052            if (result != ErrorCode.SUCCESS)
1053                throw new OpenCLException("EnqueueCopyImage failed with error code " + result, result);
1054        }
1055        public void EnqueueCopyImage(Mem src_image, Mem dst_image, int[] src_origin, int[] dst_origin, int[] region, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
1056        {
1057            ErrorCode result;
1058            IntPtr tmpEvent;
1059            IntPtr* repackedSrcOrigin = stackalloc IntPtr[3];
1060            IntPtr* repackedDstOrigin = stackalloc IntPtr[3];
1061            IntPtr* repackedRegion = stackalloc IntPtr[3];
1062            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
1063
1064            if (num_events_in_wait_list == 0)
1065                repackedEvents = null;
1066            InteropTools.A3ToIntPtr3(src_origin, repackedSrcOrigin);
1067            InteropTools.A3ToIntPtr3(dst_origin, repackedDstOrigin);
1068            InteropTools.A3ToIntPtr3(region, repackedRegion);
1069            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
1070
1071            result = OpenCL.EnqueueCopyImage(CommandQueueID, src_image, dst_image, repackedSrcOrigin, repackedDstOrigin, repackedRegion, num_events_in_wait_list, repackedEvents, &tmpEvent);
1072            _event = new Event(Context, this, tmpEvent);
1073            if (result != ErrorCode.SUCCESS)
1074                throw new OpenCLException("EnqueueCopyImage failed with error code " + result, result);
1075        }
1076        public void EnqueueCopyImage(Mem src_image, Mem dst_image, long[] src_origin, long[] dst_origin, long[] region, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
1077        {
1078            ErrorCode result;
1079            IntPtr tmpEvent;
1080            IntPtr* repackedSrcOrigin = stackalloc IntPtr[3];
1081            IntPtr* repackedDstOrigin = stackalloc IntPtr[3];
1082            IntPtr* repackedRegion = stackalloc IntPtr[3];
1083            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
1084
1085            if (num_events_in_wait_list == 0)
1086                repackedEvents = null;
1087            InteropTools.A3ToIntPtr3(src_origin, repackedSrcOrigin);
1088            InteropTools.A3ToIntPtr3(dst_origin, repackedDstOrigin);
1089            InteropTools.A3ToIntPtr3(region, repackedRegion);
1090            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
1091
1092            result = OpenCL.EnqueueCopyImage(CommandQueueID, src_image, dst_image, repackedSrcOrigin, repackedDstOrigin, repackedRegion, num_events_in_wait_list, repackedEvents, &tmpEvent);
1093            _event = new Event(Context, this, tmpEvent);
1094            if (result != ErrorCode.SUCCESS)
1095                throw new OpenCLException("EnqueueCopyImage failed with error code " + result, result);
1096        }
1097
1098        public void EnqueueCopyImage(Mem src_image, Mem dst_image, IntPtr[] src_origin, IntPtr[] dst_origin, IntPtr[] region, int num_events_in_wait_list, Event[] event_wait_list)
1099        {
1100            ErrorCode result;
1101
1102            result = OpenCL.EnqueueCopyImage(CommandQueueID,
1103                src_image.MemID,
1104                dst_image.MemID,
1105                src_origin,
1106                dst_origin,
1107                region,
1108                (uint)num_events_in_wait_list,
1109                InteropTools.ConvertEventsToEventIDs(event_wait_list),
1110                null);
1111            if (result != ErrorCode.SUCCESS)
1112                throw new OpenCLException("EnqueueCopyImage failed with error code " + result, result);
1113        }
1114        public void EnqueueCopyImage(Mem src_image, Mem dst_image, int[] src_origin, int[] dst_origin, int[] region, int num_events_in_wait_list, Event[] event_wait_list)
1115        {
1116            ErrorCode result;
1117            IntPtr* repackedSrcOrigin = stackalloc IntPtr[3];
1118            IntPtr* repackedDstOrigin = stackalloc IntPtr[3];
1119            IntPtr* repackedRegion = stackalloc IntPtr[3];
1120            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
1121
1122            if (num_events_in_wait_list == 0)
1123                repackedEvents = null;
1124            InteropTools.A3ToIntPtr3(src_origin, repackedSrcOrigin);
1125            InteropTools.A3ToIntPtr3(dst_origin, repackedDstOrigin);
1126            InteropTools.A3ToIntPtr3(region, repackedRegion);
1127            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
1128
1129            result = OpenCL.EnqueueCopyImage(CommandQueueID, src_image, dst_image, repackedSrcOrigin, repackedDstOrigin, repackedRegion, num_events_in_wait_list, repackedEvents, null);
1130            if (result != ErrorCode.SUCCESS)
1131                throw new OpenCLException("EnqueueCopyImage failed with error code " + result, result);
1132        }
1133        public void EnqueueCopyImage(Mem src_image, Mem dst_image, long[] src_origin, long[] dst_origin, long[] region, int num_events_in_wait_list, Event[] event_wait_list)
1134        {
1135            ErrorCode result;
1136            IntPtr* repackedSrcOrigin = stackalloc IntPtr[3];
1137            IntPtr* repackedDstOrigin = stackalloc IntPtr[3];
1138            IntPtr* repackedRegion = stackalloc IntPtr[3];
1139            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
1140
1141            if (num_events_in_wait_list == 0)
1142                repackedEvents = null;
1143            InteropTools.A3ToIntPtr3(src_origin, repackedSrcOrigin);
1144            InteropTools.A3ToIntPtr3(dst_origin, repackedDstOrigin);
1145            InteropTools.A3ToIntPtr3(region, repackedRegion);
1146            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
1147
1148            result = OpenCL.EnqueueCopyImage(CommandQueueID, src_image, dst_image, repackedSrcOrigin, repackedDstOrigin, repackedRegion, num_events_in_wait_list, repackedEvents, null);
1149            if (result != ErrorCode.SUCCESS)
1150                throw new OpenCLException("EnqueueCopyImage failed with error code " + result, result);
1151        }
1152
1153        public void EnqueueCopyImage(Mem src_image, Mem dst_image, IntPtr[] src_origin, IntPtr[] dst_origin, IntPtr[] region)
1154        {
1155            ErrorCode result;
1156
1157            result = OpenCL.EnqueueCopyImage(CommandQueueID,
1158                src_image.MemID,
1159                dst_image.MemID,
1160                src_origin,
1161                dst_origin,
1162                region,
1163                (uint)0,
1164                null,
1165                null);
1166            if (result != ErrorCode.SUCCESS)
1167                throw new OpenCLException("EnqueueCopyImage failed with error code " + result, result);
1168        }
1169        public void EnqueueCopyImage(Mem src_image, Mem dst_image, int[] src_origin, int[] dst_origin, int[] region)
1170        {
1171            ErrorCode result;
1172            IntPtr* repackedSrcOrigin = stackalloc IntPtr[3];
1173            IntPtr* repackedDstOrigin = stackalloc IntPtr[3];
1174            IntPtr* repackedRegion = stackalloc IntPtr[3];
1175
1176            InteropTools.A3ToIntPtr3(src_origin, repackedSrcOrigin);
1177            InteropTools.A3ToIntPtr3(dst_origin, repackedDstOrigin);
1178            InteropTools.A3ToIntPtr3(region, repackedRegion);
1179
1180            result = OpenCL.EnqueueCopyImage(CommandQueueID, src_image, dst_image, repackedSrcOrigin, repackedDstOrigin, repackedRegion, 0, null, null);
1181            if (result != ErrorCode.SUCCESS)
1182                throw new OpenCLException("EnqueueCopyImage failed with error code " + result, result);
1183        }
1184        public void EnqueueCopyImage(Mem src_image, Mem dst_image, long[] src_origin, long[] dst_origin, long[] region)
1185        {
1186            ErrorCode result;
1187            IntPtr* repackedSrcOrigin = stackalloc IntPtr[3];
1188            IntPtr* repackedDstOrigin = stackalloc IntPtr[3];
1189            IntPtr* repackedRegion = stackalloc IntPtr[3];
1190
1191            InteropTools.A3ToIntPtr3(src_origin, repackedSrcOrigin);
1192            InteropTools.A3ToIntPtr3(dst_origin, repackedDstOrigin);
1193            InteropTools.A3ToIntPtr3(region, repackedRegion);
1194
1195            result = OpenCL.EnqueueCopyImage(CommandQueueID, src_image, dst_image, repackedSrcOrigin, repackedDstOrigin, repackedRegion, 0, null, null);
1196            if (result != ErrorCode.SUCCESS)
1197                throw new OpenCLException("EnqueueCopyImage failed with error code " + result, result);
1198        }
1199
1200        #endregion
1201
1202        #region EnqueueCopyImageToBuffer
1203
1204        public void EnqueueCopyImageToBuffer(Mem src_image, Mem dst_buffer, IntPtr[] src_origin, IntPtr[] region, IntPtr dst_offset, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
1205        {
1206            ErrorCode result;
1207            IntPtr tmpEvent;
1208
1209            result = OpenCL.EnqueueCopyImageToBuffer(CommandQueueID,
1210                src_image.MemID,
1211                dst_buffer.MemID,
1212                src_origin,
1213                region,
1214                dst_offset,
1215                (uint)num_events_in_wait_list,
1216                InteropTools.ConvertEventsToEventIDs(event_wait_list),
1217                &tmpEvent);
1218            _event = new Event(Context, this, tmpEvent);
1219            if (result != ErrorCode.SUCCESS)
1220                throw new OpenCLException("EnqueueCopyImageToBuffer failed with error code " + result, result);
1221        }
1222        public void EnqueueCopyImageToBuffer(Mem src_image, Mem dst_buffer, int[] src_origin, int[] region, int dst_offset, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
1223        {
1224            ErrorCode result;
1225            IntPtr tmpEvent;
1226            IntPtr* repackedSrcOrigin = stackalloc IntPtr[3];
1227            IntPtr* repackedRegion = stackalloc IntPtr[3];
1228            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
1229
1230            if (num_events_in_wait_list == 0)
1231                repackedEvents = null;
1232            InteropTools.A3ToIntPtr3(src_origin, repackedSrcOrigin);
1233            InteropTools.A3ToIntPtr3(region, repackedRegion);
1234            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
1235
1236            result = OpenCL.EnqueueCopyImageToBuffer(CommandQueueID, src_image, dst_buffer, repackedSrcOrigin, repackedRegion, dst_offset, num_events_in_wait_list, repackedEvents, &tmpEvent);
1237            _event = new Event(Context, this, tmpEvent);
1238            if (result != ErrorCode.SUCCESS)
1239                throw new OpenCLException("EnqueueCopyImageToBuffer failed with error code " + result, result);
1240        }
1241        public void EnqueueCopyImageToBuffer(Mem src_image, Mem dst_buffer, long[] src_origin, long[] region, long dst_offset, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
1242        {
1243            ErrorCode result;
1244            IntPtr tmpEvent;
1245            IntPtr* repackedSrcOrigin = stackalloc IntPtr[3];
1246            IntPtr* repackedRegion = stackalloc IntPtr[3];
1247            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
1248
1249            if (num_events_in_wait_list == 0)
1250                repackedEvents = null;
1251            InteropTools.A3ToIntPtr3(src_origin, repackedSrcOrigin);
1252            InteropTools.A3ToIntPtr3(region, repackedRegion);
1253            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
1254
1255            result = OpenCL.EnqueueCopyImageToBuffer(CommandQueueID, src_image, dst_buffer, repackedSrcOrigin, repackedRegion, dst_offset, num_events_in_wait_list, repackedEvents, &tmpEvent);
1256            _event = new Event(Context, this, tmpEvent);
1257            if (result != ErrorCode.SUCCESS)
1258                throw new OpenCLException("EnqueueCopyImageToBuffer failed with error code " + result, result);
1259        }
1260
1261        public void EnqueueCopyImageToBuffer(Mem src_image, Mem dst_buffer, IntPtr[] src_origin, IntPtr[] region, IntPtr dst_offset, int num_events_in_wait_list, Event[] event_wait_list)
1262        {
1263            ErrorCode result;
1264
1265            result = OpenCL.EnqueueCopyImageToBuffer(CommandQueueID,
1266                src_image.MemID,
1267                dst_buffer.MemID,
1268                src_origin,
1269                region,
1270                dst_offset,
1271                (uint)num_events_in_wait_list,
1272                InteropTools.ConvertEventsToEventIDs(event_wait_list),
1273                null);
1274            if (result != ErrorCode.SUCCESS)
1275                throw new OpenCLException("EnqueueCopyImageToBuffer failed with error code " + result, result);
1276        }
1277        public void EnqueueCopyImageToBuffer(Mem src_image, Mem dst_buffer, int[] src_origin, int[] region, int dst_offset, int num_events_in_wait_list, Event[] event_wait_list)
1278        {
1279            ErrorCode result;
1280            IntPtr* repackedSrcOrigin = stackalloc IntPtr[3];
1281            IntPtr* repackedRegion = stackalloc IntPtr[3];
1282            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
1283
1284            if (num_events_in_wait_list == 0)
1285                repackedEvents = null;
1286            InteropTools.A3ToIntPtr3(src_origin, repackedSrcOrigin);
1287            InteropTools.A3ToIntPtr3(region, repackedRegion);
1288            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
1289
1290            result = OpenCL.EnqueueCopyImageToBuffer(CommandQueueID, src_image, dst_buffer, repackedSrcOrigin, repackedRegion, dst_offset, num_events_in_wait_list, repackedEvents, null);
1291            if (result != ErrorCode.SUCCESS)
1292                throw new OpenCLException("EnqueueCopyImageToBuffer failed with error code " + result, result);
1293        }
1294        public void EnqueueCopyImageToBuffer(Mem src_image, Mem dst_buffer, long[] src_origin, long[] region, long dst_offset, int num_events_in_wait_list, Event[] event_wait_list)
1295        {
1296            ErrorCode result;
1297            IntPtr* repackedSrcOrigin = stackalloc IntPtr[3];
1298            IntPtr* repackedRegion = stackalloc IntPtr[3];
1299            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
1300
1301            if (num_events_in_wait_list == 0)
1302                repackedEvents = null;
1303            InteropTools.A3ToIntPtr3(src_origin, repackedSrcOrigin);
1304            InteropTools.A3ToIntPtr3(region, repackedRegion);
1305            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
1306
1307            result = OpenCL.EnqueueCopyImageToBuffer(CommandQueueID, src_image, dst_buffer, repackedSrcOrigin, repackedRegion, dst_offset, num_events_in_wait_list, repackedEvents, null);
1308            if (result != ErrorCode.SUCCESS)
1309                throw new OpenCLException("EnqueueCopyImageToBuffer failed with error code " + result, result);
1310        }
1311
1312        public void EnqueueCopyImageToBuffer(Mem src_image, Mem dst_buffer, IntPtr[] src_origin, IntPtr[] region, IntPtr dst_offset)
1313        {
1314            ErrorCode result;
1315
1316            result = OpenCL.EnqueueCopyImageToBuffer(CommandQueueID,
1317                src_image.MemID,
1318                dst_buffer.MemID,
1319                src_origin,
1320                region,
1321                dst_offset,
1322                (uint)0,
1323                null,
1324                null);
1325            if (result != ErrorCode.SUCCESS)
1326                throw new OpenCLException("EnqueueCopyImageToBuffer failed with error code " + result, result);
1327        }
1328        public void EnqueueCopyImageToBuffer(Mem src_image, Mem dst_buffer, int[] src_origin, int[] region, int dst_offset)
1329        {
1330            ErrorCode result;
1331            IntPtr* repackedSrcOrigin = stackalloc IntPtr[3];
1332            IntPtr* repackedRegion = stackalloc IntPtr[3];
1333
1334            InteropTools.A3ToIntPtr3(src_origin, repackedSrcOrigin);
1335            InteropTools.A3ToIntPtr3(region, repackedRegion);
1336
1337            result = OpenCL.EnqueueCopyImageToBuffer(CommandQueueID, src_image, dst_buffer, repackedSrcOrigin, repackedRegion, dst_offset, 0, null, null);
1338            if (result != ErrorCode.SUCCESS)
1339                throw new OpenCLException("EnqueueCopyImageToBuffer failed with error code " + result, result);
1340        }
1341        public void EnqueueCopyImageToBuffer(Mem src_image, Mem dst_buffer, long[] src_origin, long[] region, long dst_offset)
1342        {
1343            ErrorCode result;
1344            IntPtr* repackedSrcOrigin = stackalloc IntPtr[3];
1345            IntPtr* repackedRegion = stackalloc IntPtr[3];
1346
1347            InteropTools.A3ToIntPtr3(src_origin, repackedSrcOrigin);
1348            InteropTools.A3ToIntPtr3(region, repackedRegion);
1349
1350            result = OpenCL.EnqueueCopyImageToBuffer(CommandQueueID, src_image, dst_buffer, repackedSrcOrigin, repackedRegion, dst_offset, 0, null, null);
1351            if (result != ErrorCode.SUCCESS)
1352                throw new OpenCLException("EnqueueCopyImageToBuffer failed with error code " + result, result);
1353        }
1354
1355        #endregion
1356
1357        #region EnqueueCopyBufferToImage
1358
1359        public void EnqueueCopyBufferToImage(Mem src_buffer, Mem dst_image, IntPtr src_offset, IntPtr[] dst_origin, IntPtr[] region, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
1360        {
1361            ErrorCode result;
1362            IntPtr tmpEvent;
1363
1364            result = OpenCL.EnqueueCopyBufferToImage(CommandQueueID,
1365                src_buffer.MemID,
1366                dst_image.MemID,
1367                src_offset,
1368                dst_origin,
1369                region,
1370                (uint)num_events_in_wait_list,
1371                InteropTools.ConvertEventsToEventIDs(event_wait_list),
1372                &tmpEvent);
1373            _event = new Event(Context, this, tmpEvent);
1374            if (result != ErrorCode.SUCCESS)
1375                throw new OpenCLException("EnqueueCopyBufferToImage failed with error code " + result, result);
1376        }
1377        public void EnqueueCopyBufferToImage(Mem src_buffer, Mem dst_image, int src_offset, int[] dst_origin, int[] region, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
1378        {
1379            ErrorCode result;
1380            IntPtr tmpEvent;
1381            IntPtr* repackedDstOrigin = stackalloc IntPtr[3];
1382            IntPtr* repackedRegion = stackalloc IntPtr[3];
1383            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
1384
1385            if (num_events_in_wait_list == 0)
1386                repackedEvents = null;
1387            InteropTools.A3ToIntPtr3(dst_origin, repackedDstOrigin);
1388            InteropTools.A3ToIntPtr3(region, repackedRegion);
1389            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
1390
1391            result = OpenCL.EnqueueCopyBufferToImage(CommandQueueID, src_buffer, dst_image, src_offset, repackedDstOrigin, repackedRegion, num_events_in_wait_list, repackedEvents, &tmpEvent);
1392            _event = new Event(Context, this, tmpEvent);
1393            if (result != ErrorCode.SUCCESS)
1394                throw new OpenCLException("EnqueueCopyBufferToImage failed with error code " + result, result);
1395        }
1396        public void EnqueueCopyBufferToImage(Mem src_buffer, Mem dst_image, long src_offset, long[] dst_origin, long[] region, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
1397        {
1398            ErrorCode result;
1399            IntPtr tmpEvent;
1400            IntPtr* repackedDstOrigin = stackalloc IntPtr[3];
1401            IntPtr* repackedRegion = stackalloc IntPtr[3];
1402            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
1403
1404            if (num_events_in_wait_list == 0)
1405                repackedEvents = null;
1406            InteropTools.A3ToIntPtr3(dst_origin, repackedDstOrigin);
1407            InteropTools.A3ToIntPtr3(region, repackedRegion);
1408            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
1409
1410            result = OpenCL.EnqueueCopyBufferToImage(CommandQueueID, src_buffer, dst_image, src_offset, repackedDstOrigin, repackedRegion, num_events_in_wait_list, repackedEvents, &tmpEvent);
1411            _event = new Event(Context, this, tmpEvent);
1412            if (result != ErrorCode.SUCCESS)
1413                throw new OpenCLException("EnqueueCopyBufferToImage failed with error code " + result, result);
1414        }
1415
1416        public void EnqueueCopyBufferToImage(Mem src_buffer, Mem dst_image, IntPtr src_offset, IntPtr[] dst_origin, IntPtr[] region, int num_events_in_wait_list, Event[] event_wait_list)
1417        {
1418            ErrorCode result;
1419
1420            result = OpenCL.EnqueueCopyBufferToImage(CommandQueueID,
1421                src_buffer.MemID,
1422                dst_image.MemID,
1423                src_offset,
1424                dst_origin,
1425                region,
1426                (uint)num_events_in_wait_list,
1427                InteropTools.ConvertEventsToEventIDs(event_wait_list),
1428                null);
1429            if (result != ErrorCode.SUCCESS)
1430                throw new OpenCLException("EnqueueCopyBufferToImage failed with error code " + result, result);
1431        }
1432        public void EnqueueCopyBufferToImage(Mem src_buffer, Mem dst_image, int src_offset, int[] dst_origin, int[] region, int num_events_in_wait_list, Event[] event_wait_list)
1433        {
1434            ErrorCode result;
1435            IntPtr* repackedDstOrigin = stackalloc IntPtr[3];
1436            IntPtr* repackedRegion = stackalloc IntPtr[3];
1437            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
1438
1439            if (num_events_in_wait_list == 0)
1440                repackedEvents = null;
1441            InteropTools.A3ToIntPtr3(dst_origin, repackedDstOrigin);
1442            InteropTools.A3ToIntPtr3(region, repackedRegion);
1443            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
1444
1445            result = OpenCL.EnqueueCopyBufferToImage(CommandQueueID, src_buffer, dst_image, src_offset, repackedDstOrigin, repackedRegion, num_events_in_wait_list, repackedEvents, null);
1446            if (result != ErrorCode.SUCCESS)
1447                throw new OpenCLException("EnqueueCopyBufferToImage failed with error code " + result, result);
1448        }
1449        public void EnqueueCopyBufferToImage(Mem src_buffer, Mem dst_image, long src_offset, long[] dst_origin, long[] region, int num_events_in_wait_list, Event[] event_wait_list)
1450        {
1451            ErrorCode result;
1452            IntPtr* repackedDstOrigin = stackalloc IntPtr[3];
1453            IntPtr* repackedRegion = stackalloc IntPtr[3];
1454            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
1455
1456            if (num_events_in_wait_list == 0)
1457                repackedEvents = null;
1458            InteropTools.A3ToIntPtr3(dst_origin, repackedDstOrigin);
1459            InteropTools.A3ToIntPtr3(region, repackedRegion);
1460            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
1461
1462            result = OpenCL.EnqueueCopyBufferToImage(CommandQueueID, src_buffer, dst_image, src_offset, repackedDstOrigin, repackedRegion, num_events_in_wait_list, repackedEvents, null);
1463            if (result != ErrorCode.SUCCESS)
1464                throw new OpenCLException("EnqueueCopyBufferToImage failed with error code " + result, result);
1465        }
1466
1467        public void EnqueueCopyBufferToImage(Mem src_buffer, Mem dst_image, IntPtr src_offset, IntPtr[] dst_origin, IntPtr[] region)
1468        {
1469            ErrorCode result;
1470
1471            result = OpenCL.EnqueueCopyBufferToImage(CommandQueueID,
1472                src_buffer.MemID,
1473                dst_image.MemID,
1474                src_offset,
1475                dst_origin,
1476                region,
1477                (uint)0,
1478                null,
1479                null);
1480            if (result != ErrorCode.SUCCESS)
1481                throw new OpenCLException("EnqueueCopyBufferToImage failed with error code " + result, result);
1482        }
1483        public void EnqueueCopyBufferToImage(Mem src_buffer, Mem dst_image, int src_offset, int[] dst_origin, int[] region)
1484        {
1485            ErrorCode result;
1486            IntPtr* repackedDstOrigin = stackalloc IntPtr[3];
1487            IntPtr* repackedRegion = stackalloc IntPtr[3];
1488
1489            InteropTools.A3ToIntPtr3(dst_origin, repackedDstOrigin);
1490            InteropTools.A3ToIntPtr3(region, repackedRegion);
1491
1492            result = OpenCL.EnqueueCopyBufferToImage(CommandQueueID, src_buffer, dst_image, src_offset, repackedDstOrigin, repackedRegion, 0, null, null);
1493            if (result != ErrorCode.SUCCESS)
1494                throw new OpenCLException("EnqueueCopyBufferToImage failed with error code " + result, result);
1495        }
1496        public void EnqueueCopyBufferToImage(Mem src_buffer, Mem dst_image, long src_offset, long[] dst_origin, long[] region)
1497        {
1498            ErrorCode result;
1499            IntPtr* repackedDstOrigin = stackalloc IntPtr[3];
1500            IntPtr* repackedRegion = stackalloc IntPtr[3];
1501
1502            InteropTools.A3ToIntPtr3(dst_origin, repackedDstOrigin);
1503            InteropTools.A3ToIntPtr3(region, repackedRegion);
1504
1505            result = OpenCL.EnqueueCopyBufferToImage(CommandQueueID, src_buffer, dst_image, src_offset, repackedDstOrigin, repackedRegion, 0, null, null);
1506            if (result != ErrorCode.SUCCESS)
1507                throw new OpenCLException("EnqueueCopyBufferToImage failed with error code " + result, result);
1508        }
1509
1510        #endregion
1511
1512        #region EnqueueMapBuffer
1513
1514        public IntPtr EnqueueMapBuffer(Mem buffer, bool blockingMap, MapFlags map_flags, IntPtr offset, IntPtr cb, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
1515        {
1516            ErrorCode result;
1517            IntPtr ptr;
1518            IntPtr tmpEvent;
1519
1520            ptr = (IntPtr)OpenCL.EnqueueMapBuffer(CommandQueueID,
1521                buffer.MemID,
1522                (uint)(blockingMap ? Bool.TRUE : Bool.FALSE),
1523                (ulong)map_flags,
1524                offset,
1525                cb,
1526                (uint)num_events_in_wait_list,
1527                InteropTools.ConvertEventsToEventIDs(event_wait_list),
1528                &tmpEvent,
1529                out result);
1530            _event = new Event(Context, this, tmpEvent); 
1531
1532            if (result != ErrorCode.SUCCESS)
1533                throw new OpenCLException("EnqueueMapBuffer failed with error code " + result, result);
1534            return ptr;
1535        }
1536        public IntPtr EnqueueMapBuffer(Mem buffer, bool blockingMap, MapFlags map_flags, int offset, int cb, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
1537        {
1538            void* pMappedPtr;
1539            ErrorCode result;
1540            IntPtr tmpEvent;
1541            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
1542
1543            if (num_events_in_wait_list == 0)
1544                repackedEvents = null;
1545            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
1546
1547            pMappedPtr = OpenCL.EnqueueMapBuffer(CommandQueueID, buffer, blockingMap ? (uint)Bool.TRUE : (uint)Bool.FALSE, (ulong)map_flags, offset, cb, num_events_in_wait_list, repackedEvents, &tmpEvent, out result);
1548            _event = new Event(Context, this, tmpEvent);
1549            if (result != ErrorCode.SUCCESS)
1550                throw new OpenCLException("EnqueueMapBuffer failed with error code " + result, result);
1551
1552            return (IntPtr)pMappedPtr;
1553        }
1554        public IntPtr EnqueueMapBuffer(Mem buffer, bool blockingMap, MapFlags map_flags, long offset, long cb, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
1555        {
1556            void* pMappedPtr;
1557            ErrorCode result;
1558            IntPtr tmpEvent;
1559            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
1560
1561            if (num_events_in_wait_list == 0)
1562                repackedEvents = null;
1563            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
1564
1565            pMappedPtr = OpenCL.EnqueueMapBuffer(CommandQueueID, buffer, blockingMap ? (uint)Bool.TRUE : (uint)Bool.FALSE, (ulong)map_flags, offset, cb, num_events_in_wait_list, repackedEvents, &tmpEvent, out result);
1566            _event = new Event(Context, this, tmpEvent);
1567            if (result != ErrorCode.SUCCESS)
1568                throw new OpenCLException("EnqueueMapBuffer failed with error code " + result, result);
1569            return (IntPtr)pMappedPtr;
1570        }
1571
1572        public IntPtr EnqueueMapBuffer(Mem buffer, bool blockingMap, MapFlags map_flags, IntPtr offset, IntPtr cb, int num_events_in_wait_list, Event[] event_wait_list)
1573        {
1574            ErrorCode result;
1575            IntPtr ptr;
1576
1577            ptr = (IntPtr)OpenCL.EnqueueMapBuffer(CommandQueueID,
1578                buffer.MemID,
1579                (uint)(blockingMap ? Bool.TRUE : Bool.FALSE),
1580                (ulong)map_flags,
1581                offset,
1582                cb,
1583                (uint)num_events_in_wait_list,
1584                InteropTools.ConvertEventsToEventIDs(event_wait_list),
1585                null,
1586                out result);
1587
1588            if (result != ErrorCode.SUCCESS)
1589                throw new OpenCLException("EnqueueMapBuffer failed with error code " + result, result);
1590            return ptr;
1591        }
1592        public IntPtr EnqueueMapBuffer(Mem buffer, bool blockingMap, MapFlags map_flags, int offset, int cb, int num_events_in_wait_list, Event[] event_wait_list)
1593        {
1594            void* pMappedPtr;
1595            ErrorCode result;
1596            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
1597
1598            if (num_events_in_wait_list == 0)
1599                repackedEvents = null;
1600            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
1601
1602            pMappedPtr = OpenCL.EnqueueMapBuffer(CommandQueueID, buffer, blockingMap ? (uint)Bool.TRUE : (uint)Bool.FALSE, (ulong)map_flags, offset, cb, num_events_in_wait_list, repackedEvents, null, out result);
1603            if (result != ErrorCode.SUCCESS)
1604                throw new OpenCLException("EnqueueMapBuffer failed with error code " + result, result);
1605            return (IntPtr)pMappedPtr;
1606        }
1607        public IntPtr EnqueueMapBuffer(Mem buffer, bool blockingMap, MapFlags map_flags, long offset, long cb, int num_events_in_wait_list, Event[] event_wait_list)
1608        {
1609            void* pMappedPtr;
1610            ErrorCode result;
1611            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
1612
1613            if (num_events_in_wait_list == 0)
1614                repackedEvents = null;
1615            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
1616
1617            pMappedPtr = OpenCL.EnqueueMapBuffer(CommandQueueID, buffer, blockingMap ? (uint)Bool.TRUE : (uint)Bool.FALSE, (ulong)map_flags, offset, cb, num_events_in_wait_list, repackedEvents, null, out result);
1618            if (result != ErrorCode.SUCCESS)
1619                throw new OpenCLException("EnqueueMapBuffer failed with error code " + result, result);
1620            return (IntPtr)pMappedPtr;
1621        }
1622
1623        public IntPtr EnqueueMapBuffer(Mem buffer, bool blockingMap, MapFlags map_flags, IntPtr offset, IntPtr cb)
1624        {
1625            ErrorCode result;
1626            IntPtr ptr;
1627
1628            ptr = (IntPtr)OpenCL.EnqueueMapBuffer(CommandQueueID,
1629                buffer.MemID,
1630                (uint)(blockingMap ? Bool.TRUE : Bool.FALSE),
1631                (ulong)map_flags,
1632                offset,
1633                cb,
1634                (uint)0,
1635                null,
1636                null,
1637                out result);
1638
1639            if (result != ErrorCode.SUCCESS)
1640                throw new OpenCLException("EnqueueMapBuffer failed with error code " + result, result);
1641            return ptr;
1642        }
1643        public IntPtr EnqueueMapBuffer(Mem buffer, bool blockingMap, MapFlags map_flags, int offset, int cb)
1644        {
1645            void* pMappedPtr;
1646            ErrorCode result;
1647
1648            pMappedPtr = OpenCL.EnqueueMapBuffer(CommandQueueID, buffer, blockingMap ? (uint)Bool.TRUE : (uint)Bool.FALSE, (ulong)map_flags, offset, cb, 0, null, null, out result);
1649            if (result != ErrorCode.SUCCESS)
1650                throw new OpenCLException("EnqueueMapBuffer failed with error code " + result, result);
1651            return (IntPtr)pMappedPtr;
1652        }
1653        public IntPtr EnqueueMapBuffer(Mem buffer, bool blockingMap, MapFlags map_flags, long offset, long cb)
1654        {
1655            void* pMappedPtr;
1656            ErrorCode result;
1657
1658            pMappedPtr = OpenCL.EnqueueMapBuffer(CommandQueueID, buffer, blockingMap ? (uint)Bool.TRUE : (uint)Bool.FALSE, (ulong)map_flags, offset, cb, 0, null, null, out result);
1659            if (result != ErrorCode.SUCCESS)
1660                throw new OpenCLException("EnqueueMapBuffer failed with error code " + result, result);
1661            return (IntPtr)pMappedPtr;
1662        }
1663
1664        #endregion
1665
1666        #region EnqueueMapImage
1667
1668        /// <summary>
1669        /// Map the memory of a Mem object into host memory.
1670        /// This function must be used before native code accesses an area of memory that's under the control
1671        /// of OpenCL. This includes Mem objects allocated with MemFlags.USE_HOST_PTR, as results may be cached
1672        /// in another location. Mapping will ensure caches are synchronizatized.
1673        /// </summary>
1674        /// <param name="image">Mem object to map</param>
1675        /// <param name="blockingMap">Flag that indicates if the operation is synchronous or not</param>
1676        /// <param name="map_flags">Read/Write flags</param>
1677        /// <param name="origin">origin contains the x,y,z coordinates indicating the starting point to map</param>
1678        /// <param name="region">origin contains the width,height,depth coordinates indicating the size of the area to map</param>
1679        /// <param name="image_row_pitch"></param>
1680        /// <param name="image_slice_pitch"></param>
1681        /// <param name="num_events_in_wait_list"></param>
1682        /// <param name="event_wait_list"></param>
1683        /// <param name="_event"></param>
1684        /// <param name="result"></param>
1685        /// <returns></returns>
1686        public IntPtr EnqueueMapImage(Mem image, bool blockingMap, MapFlags map_flags, IntPtr[] origin, IntPtr[] region, out IntPtr image_row_pitch, out IntPtr image_slice_pitch, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
1687        {
1688            IntPtr ptr;
1689            IntPtr tmpEvent;
1690            ErrorCode result;
1691           
1692            ptr = (IntPtr)OpenCL.EnqueueMapImage(CommandQueueID,
1693                image.MemID,
1694                (uint)(blockingMap ? Bool.TRUE : Bool.FALSE),
1695                (ulong)map_flags,
1696                origin,
1697                region,
1698                out image_row_pitch,
1699                out image_slice_pitch,
1700                (uint)num_events_in_wait_list,
1701                InteropTools.ConvertEventsToEventIDs(event_wait_list),
1702                &tmpEvent,
1703                out result);
1704            _event = new Event(Context, this, tmpEvent); 
1705            if (result != ErrorCode.SUCCESS)
1706                throw new OpenCLException("EnqueueMapImage failed with error code " + result, result);
1707            return ptr;
1708        }
1709        public IntPtr EnqueueMapImage(Mem image, bool blockingMap, MapFlags map_flags, int[] origin, int[] region, out int image_row_pitch, out int image_slice_pitch, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
1710        {
1711            void* pMappedPtr;
1712            ErrorCode result;
1713            IntPtr tmpEvent;
1714            IntPtr* repackedOrigin = stackalloc IntPtr[3];
1715            IntPtr* repackedRegion = stackalloc IntPtr[3];
1716            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
1717
1718            if (num_events_in_wait_list == 0)
1719                repackedEvents = null;
1720            InteropTools.A3ToIntPtr3(origin, repackedOrigin);
1721            InteropTools.A3ToIntPtr3(region, repackedRegion);
1722            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
1723
1724            pMappedPtr = OpenCL.EnqueueMapImage(CommandQueueID, image, (uint)(blockingMap ? Bool.TRUE : Bool.TRUE), (ulong)map_flags, repackedOrigin, repackedRegion, out image_row_pitch, out image_slice_pitch, num_events_in_wait_list, repackedEvents, &tmpEvent, out result);
1725            _event = new Event(Context, this, tmpEvent);
1726            if (result != ErrorCode.SUCCESS)
1727                throw new OpenCLException("EnqueueMapImage failed with error code " + result, result);
1728            return (IntPtr)pMappedPtr;
1729        }
1730        public IntPtr EnqueueMapImage(Mem image, bool blockingMap, MapFlags map_flags, long[] origin, long[] region, out long image_row_pitch, out long image_slice_pitch, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
1731        {
1732            void* pMappedPtr;
1733            ErrorCode result;
1734            IntPtr tmpEvent;
1735            IntPtr* repackedOrigin = stackalloc IntPtr[3];
1736            IntPtr* repackedRegion = stackalloc IntPtr[3];
1737            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
1738
1739            if (num_events_in_wait_list == 0)
1740                repackedEvents = null;
1741            InteropTools.A3ToIntPtr3(origin, repackedOrigin);
1742            InteropTools.A3ToIntPtr3(region, repackedRegion);
1743            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
1744
1745            pMappedPtr = OpenCL.EnqueueMapImage(CommandQueueID, image, (uint)(blockingMap ? Bool.TRUE : Bool.TRUE), (ulong)map_flags, repackedOrigin, repackedRegion, out image_row_pitch, out image_slice_pitch, num_events_in_wait_list, repackedEvents, &tmpEvent, out result);
1746            _event = new Event(Context, this, tmpEvent);
1747            if (result != ErrorCode.SUCCESS)
1748                throw new OpenCLException("EnqueueMapImage failed with error code " + result, result);
1749            return (IntPtr)pMappedPtr;
1750        }
1751
1752        public IntPtr EnqueueMapImage(Mem image, bool blockingMap, MapFlags map_flags, IntPtr[] origin, IntPtr[] region, out IntPtr image_row_pitch, out IntPtr image_slice_pitch, int num_events_in_wait_list, Event[] event_wait_list)
1753        {
1754            IntPtr ptr;
1755            ErrorCode result;
1756
1757            ptr = (IntPtr)OpenCL.EnqueueMapImage(CommandQueueID,
1758                image.MemID,
1759                (uint)(blockingMap ? Bool.TRUE : Bool.FALSE),
1760                (ulong)map_flags,
1761                origin,
1762                region,
1763                out image_row_pitch,
1764                out image_slice_pitch,
1765                (uint)num_events_in_wait_list,
1766                InteropTools.ConvertEventsToEventIDs(event_wait_list),
1767                null,
1768                out result);
1769            if (result != ErrorCode.SUCCESS)
1770                throw new OpenCLException("EnqueueMapImage failed with error code " + result, result);
1771            return ptr;
1772        }
1773        public IntPtr EnqueueMapImage(Mem image, bool blockingMap, MapFlags map_flags, int[] origin, int[] region, out int image_row_pitch, out int image_slice_pitch, int num_events_in_wait_list, Event[] event_wait_list)
1774        {
1775            void* pMappedPtr;
1776            ErrorCode result;
1777
1778            IntPtr* repackedOrigin = stackalloc IntPtr[3];
1779            IntPtr* repackedRegion = stackalloc IntPtr[3];
1780            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
1781
1782            if (num_events_in_wait_list == 0)
1783                repackedEvents = null;
1784            InteropTools.A3ToIntPtr3(origin, repackedOrigin);
1785            InteropTools.A3ToIntPtr3(region, repackedRegion);
1786            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
1787
1788            pMappedPtr = OpenCL.EnqueueMapImage(CommandQueueID, image, (uint)(blockingMap ? Bool.TRUE : Bool.TRUE), (ulong)map_flags, repackedOrigin, repackedRegion, out image_row_pitch, out image_slice_pitch, num_events_in_wait_list, repackedEvents, null, out result);
1789            if (result != ErrorCode.SUCCESS)
1790                throw new OpenCLException("EnqueueMapImage failed with error code " + result, result);
1791            return (IntPtr)pMappedPtr;
1792        }
1793        public IntPtr EnqueueMapImage(Mem image, bool blockingMap, MapFlags map_flags, long[] origin, long[] region, out long image_row_pitch, out long image_slice_pitch, int num_events_in_wait_list, Event[] event_wait_list)
1794        {
1795            void* pMappedPtr;
1796            ErrorCode result;
1797            IntPtr* repackedOrigin = stackalloc IntPtr[3];
1798            IntPtr* repackedRegion = stackalloc IntPtr[3];
1799            IntPtr* repackedEvents = stackalloc IntPtr[num_events_in_wait_list];
1800
1801            if (num_events_in_wait_list == 0)
1802                repackedEvents = null;
1803            InteropTools.A3ToIntPtr3(origin, repackedOrigin);
1804            InteropTools.A3ToIntPtr3(region, repackedRegion);
1805            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, repackedEvents);
1806
1807            pMappedPtr = OpenCL.EnqueueMapImage(CommandQueueID, image, (uint)(blockingMap ? Bool.TRUE : Bool.TRUE), (ulong)map_flags, repackedOrigin, repackedRegion, out image_row_pitch, out image_slice_pitch, num_events_in_wait_list, repackedEvents, null, out result);
1808            if (result != ErrorCode.SUCCESS)
1809                throw new OpenCLException("EnqueueMapImage failed with error code " + result, result);
1810            return (IntPtr)pMappedPtr;
1811        }
1812
1813        public IntPtr EnqueueMapImage(Mem image, bool blockingMap, MapFlags map_flags, IntPtr[] origin, IntPtr[] region, out IntPtr image_row_pitch, out IntPtr image_slice_pitch)
1814        {
1815            IntPtr ptr;
1816            ErrorCode result;
1817
1818            ptr = (IntPtr)OpenCL.EnqueueMapImage(CommandQueueID,
1819                image.MemID,
1820                (uint)(blockingMap ? Bool.TRUE : Bool.FALSE),
1821                (ulong)map_flags,
1822                origin,
1823                region,
1824                out image_row_pitch,
1825                out image_slice_pitch,
1826                (uint)0,
1827                null,
1828                null,
1829                out result);
1830            if (result != ErrorCode.SUCCESS)
1831                throw new OpenCLException("EnqueueMapImage failed with error code " + result, result);
1832            return ptr;
1833        }
1834        public IntPtr EnqueueMapImage(Mem image, bool blockingMap, MapFlags map_flags, int[] origin, int[] region, out int image_row_pitch, out int image_slice_pitch)
1835        {
1836            void* pMappedPtr;
1837            ErrorCode result;
1838            IntPtr* repackedOrigin = stackalloc IntPtr[3];
1839            IntPtr* repackedRegion = stackalloc IntPtr[3];
1840
1841            InteropTools.A3ToIntPtr3(origin, repackedOrigin);
1842            InteropTools.A3ToIntPtr3(region, repackedRegion);
1843
1844            pMappedPtr = OpenCL.EnqueueMapImage(CommandQueueID, image, (uint)(blockingMap ? Bool.TRUE : Bool.TRUE), (ulong)map_flags, repackedOrigin, repackedRegion, out image_row_pitch, out image_slice_pitch, 0, null, null, out result);
1845            if (result != ErrorCode.SUCCESS)
1846                throw new OpenCLException("EnqueueMapImage failed with error code " + result, result);
1847            return (IntPtr)pMappedPtr;
1848        }
1849        public IntPtr EnqueueMapImage(Mem image, bool blockingMap, MapFlags map_flags, long[] origin, long[] region, out long image_row_pitch, out long image_slice_pitch)
1850        {
1851            void* pMappedPtr;
1852            ErrorCode result;
1853            IntPtr* repackedOrigin = stackalloc IntPtr[3];
1854            IntPtr* repackedRegion = stackalloc IntPtr[3];
1855
1856            InteropTools.A3ToIntPtr3(origin, repackedOrigin);
1857            InteropTools.A3ToIntPtr3(region, repackedRegion);
1858
1859            pMappedPtr = OpenCL.EnqueueMapImage(CommandQueueID, image, (uint)(blockingMap ? Bool.TRUE : Bool.TRUE), (ulong)map_flags, repackedOrigin, repackedRegion, out image_row_pitch, out image_slice_pitch, 0, null, null, out result);
1860            if (result != ErrorCode.SUCCESS)
1861                throw new OpenCLException("EnqueueMapImage failed with error code " + result, result);
1862            return (IntPtr)pMappedPtr;
1863        }
1864
1865        #endregion
1866
1867        #region EnqueueUnmapMemObject
1868
1869        /// <summary>
1870        /// Unmap a previously mapped Mem object
1871        /// </summary>
1872        /// <param name="memobj"></param>
1873        /// <param name="mapped_ptr"></param>
1874        /// <param name="num_events_in_wait_list"></param>
1875        /// <param name="event_wait_list"></param>
1876        /// <param name="_event"></param>
1877        public void EnqueueUnmapMemObject(Mem memobj, IntPtr mapped_ptr, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
1878        {
1879            ErrorCode result;
1880            IntPtr tmpEvent;
1881
1882            result = OpenCL.EnqueueUnmapMemObject(CommandQueueID,
1883                memobj.MemID,
1884                mapped_ptr.ToPointer(),
1885                (uint)num_events_in_wait_list,
1886                InteropTools.ConvertEventsToEventIDs(event_wait_list),
1887                &tmpEvent);
1888            _event = new Event(Context, this, tmpEvent);
1889            if (result != ErrorCode.SUCCESS)
1890                throw new OpenCLException("EnqueueUnmapMemObject failed with error code " + result, result);
1891        }
1892
1893        public void EnqueueUnmapMemObject(Mem memobj, IntPtr mapped_ptr, int num_events_in_wait_list, Event[] event_wait_list)
1894        {
1895            ErrorCode result;
1896
1897            result = OpenCL.EnqueueUnmapMemObject(CommandQueueID,
1898                memobj.MemID,
1899                mapped_ptr.ToPointer(),
1900                (uint)num_events_in_wait_list,
1901                InteropTools.ConvertEventsToEventIDs(event_wait_list),
1902                null);
1903            if (result != ErrorCode.SUCCESS)
1904                throw new OpenCLException("EnqueueUnmapMemObject failed with error code " + result, result);
1905        }
1906
1907        public void EnqueueUnmapMemObject(Mem memobj, IntPtr mapped_ptr)
1908        {
1909            ErrorCode result;
1910
1911            result = OpenCL.EnqueueUnmapMemObject(CommandQueueID,
1912                memobj.MemID,
1913                mapped_ptr.ToPointer(),
1914                (uint)0,
1915                null,
1916                null);
1917            if (result != ErrorCode.SUCCESS)
1918                throw new OpenCLException("EnqueueUnmapMemObject failed with error code " + result, result);
1919        }
1920
1921        #endregion
1922
1923        #region EnqueueNDRangeKernel
1924
1925        /// <summary>
1926        /// Execute a parallel kernel.
1927        /// </summary>
1928        /// <param name="kernel"></param>
1929        /// <param name="workDim">The number of dimensions in the workspace(0-2), must correspond to the number of dimensions in the following arrays</param>
1930        /// <param name="globalWorkOffset">null in OpenCL 1.0, but will allow indices to start at non-0 locations</param>
1931        /// <param name="globalWorkSize">Index n of this array=the length of the n'th dimension of global work space</param>
1932        /// <param name="localWorkSize">Index n of this array=the length of the n'th dimension of local work space</param>
1933        /// <param name="numEventsInWaitList"></param>
1934        /// <param name="event_wait_list"></param>
1935        /// <param name="_event"></param>
1936        public void EnqueueNDRangeKernel(Kernel kernel, uint workDim, IntPtr[] globalWorkOffset, IntPtr[] globalWorkSize, IntPtr[] localWorkSize, uint numEventsInWaitList, Event[] event_wait_list, out Event _event)
1937        {
1938            ErrorCode result;
1939            IntPtr tmpEvent;
1940
1941            result = OpenCL.EnqueueNDRangeKernel(CommandQueueID,
1942                kernel.KernelID,
1943                workDim,
1944                globalWorkOffset,
1945                globalWorkSize,
1946                localWorkSize,
1947                numEventsInWaitList,
1948                InteropTools.ConvertEventsToEventIDs(event_wait_list),
1949                &tmpEvent);
1950            _event = new Event(Context, this, tmpEvent);
1951            if (result != ErrorCode.SUCCESS)
1952                throw new OpenCLException("EnqueueNDRangeKernel failed with error code " + result, result);
1953        }
1954        public void EnqueueNDRangeKernel(Kernel kernel, int workDim, int[] globalWorkOffset, int[] globalWorkSize, int[] localWorkSize, int numEventsInWaitList, Event[] event_wait_list, out Event _event)
1955        {
1956            ErrorCode result;
1957            IntPtr tmpEvent;
1958
1959            IntPtr* pGlobalWorkOffset = stackalloc IntPtr[workDim];
1960            IntPtr* pGlobalWorkSize = stackalloc IntPtr[workDim];
1961            IntPtr* pLocalWorkSize = stackalloc IntPtr[workDim];
1962            IntPtr* repackedEvents = stackalloc IntPtr[numEventsInWaitList];
1963            if (globalWorkOffset == null)
1964                pGlobalWorkOffset = null;
1965            if (globalWorkSize == null)
1966                pGlobalWorkSize = null;
1967            if (localWorkSize == null)
1968                pLocalWorkSize = null;
1969            if (event_wait_list == null)
1970                repackedEvents = null;
1971
1972            InteropTools.AToIntPtr(workDim, globalWorkOffset, pGlobalWorkOffset);
1973            InteropTools.AToIntPtr(workDim, globalWorkSize, pGlobalWorkSize);
1974            InteropTools.AToIntPtr(workDim, localWorkSize, pLocalWorkSize);
1975            InteropTools.ConvertEventsToEventIDs(numEventsInWaitList, event_wait_list, repackedEvents);
1976
1977            result = OpenCL.EnqueueNDRangeKernel(CommandQueueID,
1978                kernel.KernelID,
1979                workDim,
1980                pGlobalWorkOffset,
1981                pGlobalWorkSize,
1982                pLocalWorkSize,
1983                numEventsInWaitList,
1984                repackedEvents,
1985                &tmpEvent);
1986            _event = new Event(Context, this, tmpEvent);
1987            if (result != ErrorCode.SUCCESS)
1988                throw new OpenCLException("EnqueueNDRangeKernel failed with error code " + result, result);
1989        }
1990        public void EnqueueNDRangeKernel(Kernel kernel, int workDim, long[] globalWorkOffset, long[] globalWorkSize, long[] localWorkSize, int numEventsInWaitList, Event[] event_wait_list, out Event _event)
1991        {
1992            ErrorCode result;
1993            IntPtr tmpEvent;
1994
1995            IntPtr* pGlobalWorkOffset = stackalloc IntPtr[workDim];
1996            IntPtr* pGlobalWorkSize = stackalloc IntPtr[workDim];
1997            IntPtr* pLocalWorkSize = stackalloc IntPtr[workDim];
1998            IntPtr* repackedEvents = stackalloc IntPtr[numEventsInWaitList];
1999            if (globalWorkOffset == null)
2000                pGlobalWorkOffset = null;
2001            if (globalWorkSize == null)
2002                pGlobalWorkSize = null;
2003            if (localWorkSize == null)
2004                pLocalWorkSize = null;
2005            if (event_wait_list == null)
2006                repackedEvents = null;
2007
2008            InteropTools.AToIntPtr(workDim, globalWorkOffset, pGlobalWorkOffset);
2009            InteropTools.AToIntPtr(workDim, globalWorkSize, pGlobalWorkSize);
2010            InteropTools.AToIntPtr(workDim, localWorkSize, pLocalWorkSize);
2011            InteropTools.ConvertEventsToEventIDs(numEventsInWaitList, event_wait_list, repackedEvents);
2012
2013            result = OpenCL.EnqueueNDRangeKernel(CommandQueueID,
2014                kernel.KernelID,
2015                workDim,
2016                pGlobalWorkOffset,
2017                pGlobalWorkSize,
2018                pLocalWorkSize,
2019                numEventsInWaitList,
2020                repackedEvents,
2021                &tmpEvent);
2022            _event = new Event(Context, this, tmpEvent);
2023            if (result != ErrorCode.SUCCESS)
2024                throw new OpenCLException("EnqueueNDRangeKernel failed with error code " + result, result);
2025        }
2026
2027        public void EnqueueNDRangeKernel(Kernel kernel, uint workDim, IntPtr[] globalWorkOffset, IntPtr[] globalWorkSize, IntPtr[] localWorkSize, uint numEventsInWaitList, Event[] event_wait_list)
2028        {
2029            ErrorCode result;
2030
2031            result = OpenCL.EnqueueNDRangeKernel(CommandQueueID,
2032                kernel.KernelID,
2033                workDim,
2034                globalWorkOffset,
2035                globalWorkSize,
2036                localWorkSize,
2037                numEventsInWaitList,
2038                InteropTools.ConvertEventsToEventIDs(event_wait_list),
2039                null);
2040            if (result != ErrorCode.SUCCESS)
2041                throw new OpenCLException("EnqueueNDRangeKernel failed with error code " + result, result);
2042        }
2043        public void EnqueueNDRangeKernel(Kernel kernel, int workDim, int[] globalWorkOffset, int[] globalWorkSize, int[] localWorkSize, int numEventsInWaitList, Event[] event_wait_list)
2044        {
2045            ErrorCode result;
2046
2047            IntPtr* pGlobalWorkOffset = stackalloc IntPtr[workDim];
2048            IntPtr* pGlobalWorkSize = stackalloc IntPtr[workDim];
2049            IntPtr* pLocalWorkSize = stackalloc IntPtr[workDim];
2050            IntPtr* repackedEvents = stackalloc IntPtr[numEventsInWaitList];
2051            if (globalWorkOffset == null)
2052                pGlobalWorkOffset = null;
2053            if (globalWorkSize == null)
2054                pGlobalWorkSize = null;
2055            if (localWorkSize == null)
2056                pLocalWorkSize = null;
2057            if (event_wait_list == null)
2058                repackedEvents = null;
2059
2060            InteropTools.AToIntPtr(workDim, globalWorkOffset, pGlobalWorkOffset);
2061            InteropTools.AToIntPtr(workDim, globalWorkSize, pGlobalWorkSize);
2062            InteropTools.AToIntPtr(workDim, localWorkSize, pLocalWorkSize);
2063            InteropTools.ConvertEventsToEventIDs(numEventsInWaitList, event_wait_list, repackedEvents);
2064
2065            result = OpenCL.EnqueueNDRangeKernel(CommandQueueID,
2066                kernel.KernelID,
2067                workDim,
2068                pGlobalWorkOffset,
2069                pGlobalWorkSize,
2070                pLocalWorkSize,
2071                numEventsInWaitList,
2072                repackedEvents,
2073                null);
2074            if (result != ErrorCode.SUCCESS)
2075                throw new OpenCLException("EnqueueNDRangeKernel failed with error code " + result, result);
2076        }
2077        public void EnqueueNDRangeKernel(Kernel kernel, int workDim, long[] globalWorkOffset, long[] globalWorkSize, long[] localWorkSize, int numEventsInWaitList, Event[] event_wait_list)
2078        {
2079            ErrorCode result;
2080
2081            IntPtr* pGlobalWorkOffset = stackalloc IntPtr[workDim];
2082            IntPtr* pGlobalWorkSize = stackalloc IntPtr[workDim];
2083            IntPtr* pLocalWorkSize = stackalloc IntPtr[workDim];
2084            IntPtr* repackedEvents = stackalloc IntPtr[numEventsInWaitList];
2085            if (globalWorkOffset == null)
2086                pGlobalWorkOffset = null;
2087            if (globalWorkSize == null)
2088                pGlobalWorkSize = null;
2089            if (localWorkSize == null)
2090                pLocalWorkSize = null;
2091            if (event_wait_list == null)
2092                repackedEvents = null;
2093
2094            InteropTools.AToIntPtr(workDim, globalWorkOffset, pGlobalWorkOffset);
2095            InteropTools.AToIntPtr(workDim, globalWorkSize, pGlobalWorkSize);
2096            InteropTools.AToIntPtr(workDim, localWorkSize, pLocalWorkSize);
2097            InteropTools.ConvertEventsToEventIDs(numEventsInWaitList, event_wait_list, repackedEvents);
2098
2099            result = OpenCL.EnqueueNDRangeKernel(CommandQueueID,
2100                kernel.KernelID,
2101                workDim,
2102                pGlobalWorkOffset,
2103                pGlobalWorkSize,
2104                pLocalWorkSize,
2105                numEventsInWaitList,
2106                repackedEvents,
2107                null);
2108            if (result != ErrorCode.SUCCESS)
2109                throw new OpenCLException("EnqueueNDRangeKernel failed with error code " + result, result);
2110        }
2111
2112        public void EnqueueNDRangeKernel(Kernel kernel, uint workDim, IntPtr[] globalWorkOffset, IntPtr[] globalWorkSize, IntPtr[] localWorkSize)
2113        {
2114            ErrorCode result;
2115
2116            result = OpenCL.EnqueueNDRangeKernel(CommandQueueID,
2117                kernel.KernelID,
2118                workDim,
2119                globalWorkOffset,
2120                globalWorkSize,
2121                localWorkSize,
2122                0,
2123                null,
2124                null);
2125            if (result != ErrorCode.SUCCESS)
2126                throw new OpenCLException("EnqueueNDRangeKernel failed with error code " + result, result);
2127        }
2128        public void EnqueueNDRangeKernel(Kernel kernel, int workDim, int[] globalWorkOffset, int[] globalWorkSize, int[] localWorkSize)
2129        {
2130            ErrorCode result;
2131
2132            IntPtr* pGlobalWorkOffset = stackalloc IntPtr[workDim];
2133            IntPtr* pGlobalWorkSize = stackalloc IntPtr[workDim];
2134            IntPtr* pLocalWorkSize = stackalloc IntPtr[workDim];
2135            if (globalWorkOffset == null)
2136                pGlobalWorkOffset = null;
2137            if (globalWorkSize == null)
2138                pGlobalWorkSize = null;
2139            if (localWorkSize == null)
2140                pLocalWorkSize = null;
2141
2142            InteropTools.AToIntPtr(workDim, globalWorkOffset, pGlobalWorkOffset);
2143            InteropTools.AToIntPtr(workDim, globalWorkSize, pGlobalWorkSize);
2144            InteropTools.AToIntPtr(workDim, localWorkSize, pLocalWorkSize);
2145
2146            result = OpenCL.EnqueueNDRangeKernel(CommandQueueID,
2147                kernel.KernelID,
2148                workDim,
2149                pGlobalWorkOffset,
2150                pGlobalWorkSize,
2151                pLocalWorkSize,
2152                0,
2153                null,
2154                null);
2155            if (result != ErrorCode.SUCCESS)
2156                throw new OpenCLException("EnqueueNDRangeKernel failed with error code " + result, result);
2157        }
2158        public void EnqueueNDRangeKernel(Kernel kernel, int workDim, long[] globalWorkOffset, long[] globalWorkSize, long[] localWorkSize)
2159        {
2160            ErrorCode result;
2161
2162            IntPtr* pGlobalWorkOffset = stackalloc IntPtr[workDim];
2163            IntPtr* pGlobalWorkSize = stackalloc IntPtr[workDim];
2164            IntPtr* pLocalWorkSize = stackalloc IntPtr[workDim];
2165            if (globalWorkOffset == null)
2166                pGlobalWorkOffset = null;
2167            if (globalWorkSize == null)
2168                pGlobalWorkSize = null;
2169            if (localWorkSize == null)
2170                pLocalWorkSize = null;
2171
2172            InteropTools.AToIntPtr(workDim, globalWorkOffset, pGlobalWorkOffset);
2173            InteropTools.AToIntPtr(workDim, globalWorkSize, pGlobalWorkSize);
2174            InteropTools.AToIntPtr(workDim, localWorkSize, pLocalWorkSize);
2175
2176            result = OpenCL.EnqueueNDRangeKernel(CommandQueueID,
2177                kernel.KernelID,
2178                workDim,
2179                pGlobalWorkOffset,
2180                pGlobalWorkSize,
2181                pLocalWorkSize,
2182                0,
2183                null,
2184                null);
2185            if (result != ErrorCode.SUCCESS)
2186                throw new OpenCLException("EnqueueNDRangeKernel failed with error code " + result, result);
2187        }
2188
2189        #endregion
2190
2191        #region EnqueueTask
2192
2193        /// <summary>
2194        /// Execute a simple kernel
2195        /// </summary>
2196        /// <param name="kernel"></param>
2197        /// <param name="numEventsInWaitList"></param>
2198        /// <param name="event_wait_list"></param>
2199        /// <param name="_event"></param>
2200        public void EnqueueTask(Kernel kernel, int numEventsInWaitList, Event[] event_wait_list, out Event _event)
2201        {
2202            ErrorCode result;
2203            IntPtr tmpEvent;
2204
2205            result = (ErrorCode)OpenCL.EnqueueTask(CommandQueueID,
2206                kernel.KernelID,
2207                (uint)numEventsInWaitList,
2208                InteropTools.ConvertEventsToEventIDs(event_wait_list),
2209                &tmpEvent);
2210            _event = new Event(Context, this, tmpEvent);
2211            if (result != ErrorCode.SUCCESS)
2212                throw new OpenCLException("EnqueueTask failed with error code " + result, result);
2213        }
2214
2215        /// <summary>
2216        /// Execute a simple kernel
2217        /// </summary>
2218        /// <param name="kernel"></param>
2219        /// <param name="numEventsInWaitList"></param>
2220        /// <param name="event_wait_list"></param>
2221        public void EnqueueTask(Kernel kernel, int numEventsInWaitList, Event[] event_wait_list)
2222        {
2223            ErrorCode result;
2224
2225            result = (ErrorCode)OpenCL.EnqueueTask(CommandQueueID,
2226                kernel.KernelID,
2227                (uint)numEventsInWaitList,
2228                InteropTools.ConvertEventsToEventIDs(event_wait_list),
2229                null);
2230            if (result != ErrorCode.SUCCESS)
2231                throw new OpenCLException("EnqueueTask failed with error code " + result, result);
2232        }
2233
2234        /// <summary>
2235        /// Execute a simple kernel
2236        /// </summary>
2237        /// <param name="kernel"></param>
2238        public void EnqueueTask(Kernel kernel)
2239        {
2240            ErrorCode result;
2241
2242            result = (ErrorCode)OpenCL.EnqueueTask(CommandQueueID,
2243                kernel.KernelID,
2244                (uint)0,
2245                null,
2246                null);
2247            if (result != ErrorCode.SUCCESS)
2248                throw new OpenCLException("EnqueueTask failed with error code " + result, result);
2249        }
2250
2251        #endregion
2252
2253        #region EnqueueNativeKernel
2254
2255        internal class NativeKernelCallbackData
2256        {
2257            internal NativeKernel NativeKernel;
2258            internal CommandQueue CQ;
2259            internal object O;
2260            internal Mem [] Buffers;
2261
2262            internal NativeKernelCallbackData(NativeKernel nk,CommandQueue cq, object o, Mem[] buffers)
2263            {
2264                NativeKernel = nk;
2265                CQ = cq;
2266                O = o;
2267                Buffers = buffers;
2268            }
2269        }
2270
2271        private static Mutex NativeKernelParamsMutex = new Mutex();
2272        private static int NativeKernelParamsId = 0;
2273        private static NativeKernelInternal NativeKernelDelegate = new NativeKernelInternal(NativeKernelCallback);
2274        private static Dictionary<int, NativeKernelCallbackData> NativeKernelDispatch = new Dictionary<int, NativeKernelCallbackData>();
2275       
2276        unsafe private static void NativeKernelCallback( void* args )
2277        {
2278            int callbackId = *(int*)args;
2279            NativeKernelCallbackData callbackData = GetCallback(callbackId);
2280            void*[] buffers;
2281
2282            if( callbackData.Buffers!=null )
2283            {
2284                buffers = new void*[callbackData.Buffers.Length];
2285                for (int i = 0; i < buffers.Length; i++)
2286                    buffers[i] = callbackData.CQ.EnqueueMapBuffer(callbackData.Buffers[i], true, MapFlags.READ_WRITE, IntPtr.Zero, callbackData.Buffers[i].MemSize).ToPointer();
2287            }
2288            else
2289                buffers = null;
2290
2291            callbackData.NativeKernel(callbackData.O, buffers);
2292
2293            if (buffers != null)
2294            {
2295                for (int i = 0; i < buffers.Length; i++)
2296                    callbackData.CQ.EnqueueUnmapMemObject(callbackData.Buffers[i], (IntPtr)buffers[i]);
2297            }           
2298            RemoveCallback(callbackId);
2299        }
2300
2301        private static int AddNativeKernelParams( NativeKernel nk, CommandQueue cq, object o, Mem[] buffers)
2302        {
2303            int callbackId;
2304            NativeKernelCallbackData callbackData = new NativeKernelCallbackData(nk, cq, o, buffers);
2305            bool gotMutex = false;
2306            try
2307            {
2308                gotMutex = NativeKernelParamsMutex.WaitOne();
2309                do
2310                {
2311                    callbackId = NativeKernelParamsId++;
2312                } while (NativeKernelDispatch.ContainsKey(callbackId));
2313                NativeKernelDispatch.Add(callbackId, callbackData);
2314            }
2315            finally
2316            {
2317                if (gotMutex)
2318                    NativeKernelParamsMutex.ReleaseMutex();
2319            }
2320            return callbackId;
2321        }
2322
2323        private static NativeKernelCallbackData GetCallback(int callbackId)
2324        {
2325            NativeKernelCallbackData callbackData = null;
2326            bool gotMutex = false;
2327            try
2328            {
2329                gotMutex = NativeKernelParamsMutex.WaitOne();
2330                callbackData = NativeKernelDispatch[callbackId];
2331            }
2332            finally
2333            {
2334                if (gotMutex)
2335                    NativeKernelParamsMutex.ReleaseMutex();
2336            }
2337            return callbackData;
2338        }
2339
2340
2341        private static void RemoveCallback(int callbackId)
2342        {
2343            bool gotMutex = false;
2344            try
2345            {
2346                gotMutex = NativeKernelParamsMutex.WaitOne();
2347                NativeKernelDispatch.Remove(callbackId);
2348            }
2349            finally
2350            {
2351                if (gotMutex)
2352                    NativeKernelParamsMutex.ReleaseMutex();
2353            }
2354        }
2355
2356        /// <summary>
2357        /// Enqueue a user function. This function is only supported if
2358        /// DeviceExecCapabilities.NATIVE_KERNEL set in Device.ExecutionCapabilities
2359        /// </summary>
2360        /// <param name="nativeKernel"></param>
2361        /// <param name="numEventsInWaitList"></param>
2362        /// <param name="event_wait_list"></param>
2363        /// <param name="_event"></param>
2364        public void EnqueueNativeKernel(NativeKernel nativeKernel, object userObject, Mem[] buffers, int numEventsInWaitList, Event[] event_wait_list, out Event _event)
2365        {
2366            ErrorCode result;
2367            IntPtr tmpEvent;
2368            int callbackId;
2369           
2370            callbackId = AddNativeKernelParams(nativeKernel, this, userObject, buffers);
2371            result = OpenCL.EnqueueNativeKernel(CommandQueueID,
2372                NativeKernelDelegate,
2373                &callbackId,
2374                (IntPtr)4,
2375                0,
2376                null,
2377                null,
2378                (uint)numEventsInWaitList,
2379                InteropTools.ConvertEventsToEventIDs(event_wait_list),
2380                &tmpEvent);
2381            if (result != ErrorCode.SUCCESS)
2382                throw new OpenCLException("EnqueueNativeKernel failed with error code " + result, result);
2383            _event = new Event(Context, this, tmpEvent);
2384        }
2385
2386        /// <summary>
2387        /// Enquque a user function. This function is only supported if
2388        /// DeviceExecCapabilities.NATIVE_KERNEL set in Device.ExecutionCapabilities
2389        /// </summary>
2390        /// <param name="nativeKernel"></param>
2391        /// <param name="numEventsInWaitList"></param>
2392        /// <param name="event_wait_list"></param>
2393        public void EnqueueNativeKernel(NativeKernel nativeKernel, object userObject, Mem[] buffers, int numEventsInWaitList, Event[] event_wait_list)
2394        {
2395            ErrorCode result;
2396            int callbackId;
2397
2398            callbackId = AddNativeKernelParams(nativeKernel, this, userObject, buffers);
2399            result = OpenCL.EnqueueNativeKernel(CommandQueueID,
2400                NativeKernelDelegate,
2401                &callbackId,
2402                (IntPtr)4,
2403                0,
2404                null,
2405                null,
2406                (uint)numEventsInWaitList,
2407                InteropTools.ConvertEventsToEventIDs( event_wait_list ),
2408                null);
2409            if (result != ErrorCode.SUCCESS)
2410                throw new OpenCLException("EnqueueNativeKernel failed with error code " + result, result);
2411        }
2412
2413        /// <summary>
2414        /// Enquque a user function. This function is only supported if
2415        /// DeviceExecCapabilities.NATIVE_KERNEL set in Device.ExecutionCapabilities
2416        /// </summary>
2417        /// <param name="nativeKernel"></param>
2418        public void EnqueueNativeKernel(NativeKernel nativeKernel, object userObject, Mem[] buffers)
2419        {
2420            ErrorCode result;
2421            int callbackId;
2422
2423            callbackId = AddNativeKernelParams(nativeKernel, this, userObject, buffers);
2424            result = OpenCL.EnqueueNativeKernel(CommandQueueID,
2425                NativeKernelDelegate,
2426                &callbackId,
2427                (IntPtr)4,
2428                0,
2429                null,
2430                null,
2431                0,
2432                null,
2433                null);
2434            if (result != ErrorCode.SUCCESS)
2435                throw new OpenCLException("EnqueueNativeKernel failed with error code " + result, result);
2436        }
2437
2438        #endregion
2439
2440        #region EnqueueAcquireGLObjects
2441
2442        public void EnqueueAcquireGLObjects(int numObjects, Mem[] memObjects, int numEventsInWaitList, Event[] event_wait_list, out Event _event)
2443        {
2444            IntPtr tmpEvent;
2445            ErrorCode result;
2446
2447            result = OpenCL.EnqueueAcquireGLObjects(CommandQueueID,
2448                (uint)numObjects,
2449                InteropTools.ConvertMemToMemIDs(memObjects),
2450                (uint)numEventsInWaitList,
2451                InteropTools.ConvertEventsToEventIDs(event_wait_list),
2452                &tmpEvent);
2453            if (result != ErrorCode.SUCCESS)
2454                throw new OpenCLException("EnqueueAcquireGLObjects failed with error code " + result, result);
2455            _event = new Event(Context, this, tmpEvent);
2456        }
2457
2458        public void EnqueueAcquireGLObjects(int numObjects, Mem[] memObjects, int numEventsInWaitList, Event[] event_wait_list)
2459        {
2460            ErrorCode result;
2461
2462            result = OpenCL.EnqueueAcquireGLObjects(CommandQueueID,
2463                (uint)numObjects,
2464                InteropTools.ConvertMemToMemIDs(memObjects),
2465                (uint)numEventsInWaitList,
2466                InteropTools.ConvertEventsToEventIDs(event_wait_list),
2467                null);
2468            if (result != ErrorCode.SUCCESS)
2469                throw new OpenCLException("EnqueueAcquireGLObjects failed with error code " + result, result);
2470        }
2471
2472        public void EnqueueAcquireGLObjects(int numObjects, Mem[] memObjects)
2473        {
2474            ErrorCode result;
2475
2476            result = OpenCL.EnqueueAcquireGLObjects(CommandQueueID,
2477                (uint)numObjects,
2478                InteropTools.ConvertMemToMemIDs(memObjects),
2479                (uint)0,
2480                null,
2481                null);
2482            if (result != ErrorCode.SUCCESS)
2483                throw new OpenCLException("EnqueueAcquireGLObjects failed with error code " + result, result);
2484        }
2485
2486        #endregion
2487
2488        #region EnqueueReleaseGLObjects
2489
2490        public void EnqueueReleaseGLObjects(int numObjects, Mem[] memObjects, int numEventsInWaitList, Event[] event_wait_list, out Event _event)
2491        {
2492            IntPtr tmpEvent;
2493            ErrorCode result;
2494
2495            result = OpenCL.EnqueueReleaseGLObjects(CommandQueueID,
2496                (uint)numObjects,
2497                InteropTools.ConvertMemToMemIDs(memObjects),
2498                (uint)numEventsInWaitList,
2499                InteropTools.ConvertEventsToEventIDs(event_wait_list),
2500                &tmpEvent);
2501            if (result != ErrorCode.SUCCESS)
2502                throw new OpenCLException("EnqueueReleaseGLObjects failed with error code " + result, result);
2503            _event = new Event(Context, this, tmpEvent);
2504        }
2505
2506        public void EnqueueReleaseGLObjects(int numObjects, Mem[] memObjects, int numEventsInWaitList, Event[] event_wait_list)
2507        {
2508            ErrorCode result;
2509
2510            result = OpenCL.EnqueueReleaseGLObjects(CommandQueueID,
2511                (uint)numObjects,
2512                InteropTools.ConvertMemToMemIDs(memObjects),
2513                (uint)numEventsInWaitList,
2514                InteropTools.ConvertEventsToEventIDs(event_wait_list),
2515                null);
2516            if (result != ErrorCode.SUCCESS)
2517                throw new OpenCLException("EnqueueReleaseGLObjects failed with error code " + result, result);
2518        }
2519
2520        public void EnqueueReleaseGLObjects(int numObjects, Mem[] memObjects)
2521        {
2522            ErrorCode result;
2523
2524            result = OpenCL.EnqueueReleaseGLObjects(CommandQueueID,
2525                (uint)numObjects,
2526                InteropTools.ConvertMemToMemIDs(memObjects),
2527                (uint)0,
2528                null,
2529                null);
2530            if (result != ErrorCode.SUCCESS)
2531                throw new OpenCLException("EnqueueReleaseGLObjects failed with error code " + result, result);
2532        }
2533
2534        #endregion
2535
2536        #region EnqueueMarker
2537
2538        public void EnqueueMarker( out Event _event )
2539        {
2540            IntPtr tmpEvent;
2541
2542            OpenCL.EnqueueMarker(CommandQueueID, &tmpEvent);
2543            _event = new Event(Context, this, tmpEvent);
2544        }
2545
2546        #endregion
2547
2548        #region EnqueueWaitForEvents
2549
2550        public void EnqueueWaitForEvents(int num_events, Event[] _event_list)
2551        {
2552            OpenCL.EnqueueWaitForEvents(CommandQueueID, (uint)num_events, InteropTools.ConvertEventsToEventIDs(_event_list));
2553        }
2554
2555        public void EnqueueWaitForEvent( Event _event)
2556        {
2557            Event[] waitList = new Event[] { _event };
2558            EnqueueWaitForEvents(1, waitList);
2559        }
2560
2561        #endregion
2562
2563        #region EnqueueBarrier
2564
2565        public void EnqueueBarrier()
2566        {
2567            OpenCL.EnqueueBarrier(CommandQueueID);
2568        }
2569
2570        #endregion
2571
2572        #region Flush
2573
2574        public void Flush()
2575        {
2576            OpenCL.Flush(CommandQueueID);
2577        }
2578
2579        #endregion
2580
2581        #region Finish
2582
2583        public void Finish()
2584        {
2585            OpenCL.Finish(CommandQueueID);
2586        }
2587
2588        #endregion
2589
2590        #region SetProperty
2591
2592        [Obsolete("Function deprecated in OpenCL 1.1 due to being inherently unsafe", false)]
2593        public void SetProperty(CommandQueueProperties properties, bool enable, out CommandQueueProperties oldProperties)
2594        {
2595            ErrorCode result;
2596            ulong returnedProperties = 0;
2597#pragma warning disable 618
2598            result = (ErrorCode)OpenCL.SetCommandQueueProperty( CommandQueueID,
2599                (ulong)properties,
2600                enable,
2601                out returnedProperties );
2602            if( result!=ErrorCode.SUCCESS )
2603                throw new OpenCLException( "SetCommandQueueProperty failed with error code "+result , result);
2604            oldProperties = (CommandQueueProperties)returnedProperties;
2605#pragma warning restore 618
2606        }
2607
2608        #endregion
2609
2610        #region EnqueueReadBufferRect
2611
2612        /// <summary>
2613        /// OpenCL 1.1
2614        /// </summary>
2615        /// <param name="command_queue"></param>
2616        /// <param name="buffer"></param>
2617        /// <param name="blocking_read"></param>
2618        /// <param name="buffer_offset"></param>
2619        /// <param name="host_offset"></param>
2620        /// <param name="region"></param>
2621        /// <param name="buffer_row_pitch"></param>
2622        /// <param name="buffer_slice_pitch"></param>
2623        /// <param name="host_row_pitch"></param>
2624        /// <param name="host_slice_pitch"></param>
2625        /// <param name="ptr"></param>
2626        /// <param name="num_events_in_wait_list"></param>
2627        /// <param name="event_wait_list"></param>
2628        /// <param name="_event"></param>
2629        public void EnqueueReadBufferRect(Mem buffer,
2630                                bool blocking_read,
2631                                IntPtr[] buffer_offset,
2632                                IntPtr[] host_offset,
2633                                IntPtr[] region,
2634                                IntPtr buffer_row_pitch,
2635                                IntPtr buffer_slice_pitch,
2636                                IntPtr host_row_pitch,
2637                                IntPtr host_slice_pitch,
2638                                IntPtr ptr,
2639                                uint num_events_in_wait_list,
2640                                Event[] event_wait_list,
2641                                out Event _event)
2642        {
2643            ErrorCode result;
2644            IntPtr tmpEvent;
2645
2646            result = OpenCL.EnqueueReadBufferRect(CommandQueueID,
2647                buffer.MemID,
2648                (uint)(blocking_read ? Bool.TRUE : Bool.FALSE),
2649                buffer_offset,
2650                host_offset,
2651                region,
2652                buffer_row_pitch,
2653                buffer_slice_pitch,
2654                host_row_pitch,
2655                host_slice_pitch,
2656                ptr.ToPointer(),
2657                num_events_in_wait_list,
2658                InteropTools.ConvertEventsToEventIDs(event_wait_list),
2659                &tmpEvent);
2660            _event = new Event(Context, this, tmpEvent);
2661            if (result != ErrorCode.SUCCESS)
2662                throw new OpenCLException("EnqueueReadBufferRect failed with error code " + result, result);
2663        }
2664        public void EnqueueReadBufferRect(Mem buffer, bool blocking_read, int[] buffer_offset, int[] host_offset, int[] region, int buffer_row_pitch, int buffer_slice_pitch, int host_row_pitch, int host_slice_pitch, IntPtr ptr, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
2665        {
2666            ErrorCode result;
2667            IntPtr tmpEvent;
2668            IntPtr* pBufferOffset = stackalloc IntPtr[3];
2669            IntPtr* pHostOffset = stackalloc IntPtr[3];
2670            IntPtr* pRegion = stackalloc IntPtr[3];
2671            IntPtr* pRepackedEvents = stackalloc IntPtr[num_events_in_wait_list];
2672
2673            if (num_events_in_wait_list == 0)
2674                pRepackedEvents = null;
2675            InteropTools.A3ToIntPtr3(buffer_offset, pBufferOffset);
2676            InteropTools.A3ToIntPtr3(host_offset, pHostOffset);
2677            InteropTools.A3ToIntPtr3(region, pRegion);
2678            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, pRepackedEvents);
2679
2680            result = OpenCL.EnqueueReadBufferRect(CommandQueueID,
2681                buffer.MemID,
2682                (uint)(blocking_read ? Bool.TRUE : Bool.FALSE),
2683                pBufferOffset,
2684                pHostOffset,
2685                pRegion,
2686                buffer_row_pitch,
2687                buffer_slice_pitch,
2688                host_row_pitch,
2689                host_slice_pitch,
2690                ptr.ToPointer(),
2691                num_events_in_wait_list,
2692                pRepackedEvents,
2693                &tmpEvent);
2694            _event = new Event(Context, this, tmpEvent);
2695            if (result != ErrorCode.SUCCESS)
2696                throw new OpenCLException("EnqueueReadBufferRect failed with error code " + result, result);
2697        }
2698        public void EnqueueReadBufferRect(Mem buffer, bool blocking_read, long[] buffer_offset, long[] host_offset, long[] region, long buffer_row_pitch, long buffer_slice_pitch, long host_row_pitch, long host_slice_pitch, IntPtr ptr, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
2699        {
2700            ErrorCode result;
2701            IntPtr tmpEvent;
2702            IntPtr* pBufferOffset = stackalloc IntPtr[3];
2703            IntPtr* pHostOffset = stackalloc IntPtr[3];
2704            IntPtr* pRegion = stackalloc IntPtr[3];
2705            IntPtr* pRepackedEvents = stackalloc IntPtr[num_events_in_wait_list];
2706
2707            if (num_events_in_wait_list == 0)
2708                pRepackedEvents = null;
2709            InteropTools.A3ToIntPtr3(buffer_offset, pBufferOffset);
2710            InteropTools.A3ToIntPtr3(host_offset, pHostOffset);
2711            InteropTools.A3ToIntPtr3(region, pRegion);
2712            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, pRepackedEvents);
2713
2714            result = OpenCL.EnqueueReadBufferRect(CommandQueueID,
2715                buffer.MemID,
2716                (uint)(blocking_read ? Bool.TRUE : Bool.FALSE),
2717                pBufferOffset,
2718                pHostOffset,
2719                pRegion,
2720                buffer_row_pitch,
2721                buffer_slice_pitch,
2722                host_row_pitch,
2723                host_slice_pitch,
2724                ptr.ToPointer(),
2725                num_events_in_wait_list,
2726                pRepackedEvents,
2727                &tmpEvent);
2728            _event = new Event(Context, this, tmpEvent);
2729            if (result != ErrorCode.SUCCESS)
2730                throw new OpenCLException("EnqueueReadBufferRect failed with error code " + result, result);
2731        }
2732
2733        public void EnqueueReadBufferRect( Mem buffer,
2734                                bool blocking_read,
2735                                IntPtr[] buffer_offset,
2736                                IntPtr[] host_offset,
2737                                IntPtr[] region,
2738                                IntPtr buffer_row_pitch,
2739                                IntPtr buffer_slice_pitch,
2740                                IntPtr host_row_pitch,
2741                                IntPtr host_slice_pitch,
2742                                IntPtr ptr,
2743                                uint num_events_in_wait_list,
2744                                Event[] event_wait_list)
2745        {
2746            ErrorCode result;
2747
2748            result = OpenCL.EnqueueReadBufferRect(CommandQueueID,
2749                buffer.MemID,
2750                (uint)(blocking_read ? Bool.TRUE : Bool.FALSE),
2751                buffer_offset,
2752                host_offset,
2753                region,
2754                buffer_row_pitch,
2755                buffer_slice_pitch,
2756                host_row_pitch,
2757                host_slice_pitch,
2758                ptr.ToPointer(),
2759                num_events_in_wait_list,
2760                InteropTools.ConvertEventsToEventIDs(event_wait_list),
2761                null);
2762            if (result != ErrorCode.SUCCESS)
2763                throw new OpenCLException("EnqueueReadBufferRect failed with error code " + result, result);
2764        }
2765        public void EnqueueReadBufferRect(Mem buffer, bool blocking_read, int[] buffer_offset, int[] host_offset, int[] region, int buffer_row_pitch, int buffer_slice_pitch, int host_row_pitch, int host_slice_pitch, IntPtr ptr, int num_events_in_wait_list, Event[] event_wait_list)
2766        {
2767            ErrorCode result;
2768            IntPtr* pBufferOffset = stackalloc IntPtr[3];
2769            IntPtr* pHostOffset = stackalloc IntPtr[3];
2770            IntPtr* pRegion = stackalloc IntPtr[3];
2771            IntPtr* pRepackedEvents = stackalloc IntPtr[num_events_in_wait_list];
2772
2773            if (num_events_in_wait_list == 0)
2774                pRepackedEvents = null;
2775            InteropTools.A3ToIntPtr3(buffer_offset, pBufferOffset);
2776            InteropTools.A3ToIntPtr3(host_offset, pHostOffset);
2777            InteropTools.A3ToIntPtr3(region, pRegion);
2778            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, pRepackedEvents);
2779
2780            result = OpenCL.EnqueueReadBufferRect(CommandQueueID,
2781                buffer.MemID,
2782                (uint)(blocking_read ? Bool.TRUE : Bool.FALSE),
2783                pBufferOffset,
2784                pHostOffset,
2785                pRegion,
2786                buffer_row_pitch,
2787                buffer_slice_pitch,
2788                host_row_pitch,
2789                host_slice_pitch,
2790                ptr.ToPointer(),
2791                num_events_in_wait_list,
2792                pRepackedEvents,
2793                null);
2794            if (result != ErrorCode.SUCCESS)
2795                throw new OpenCLException("EnqueueReadBufferRect failed with error code " + result, result);
2796        }
2797        public void EnqueueReadBufferRect(Mem buffer, bool blocking_read, long[] buffer_offset, long[] host_offset, long[] region, long buffer_row_pitch, long buffer_slice_pitch, long host_row_pitch, long host_slice_pitch, IntPtr ptr, int num_events_in_wait_list, Event[] event_wait_list)
2798        {
2799            ErrorCode result;
2800            IntPtr* pBufferOffset = stackalloc IntPtr[3];
2801            IntPtr* pHostOffset = stackalloc IntPtr[3];
2802            IntPtr* pRegion = stackalloc IntPtr[3];
2803            IntPtr* pRepackedEvents = stackalloc IntPtr[num_events_in_wait_list];
2804
2805            if (num_events_in_wait_list == 0)
2806                pRepackedEvents = null;
2807            InteropTools.A3ToIntPtr3(buffer_offset, pBufferOffset);
2808            InteropTools.A3ToIntPtr3(host_offset, pHostOffset);
2809            InteropTools.A3ToIntPtr3(region, pRegion);
2810            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, pRepackedEvents);
2811
2812            result = OpenCL.EnqueueReadBufferRect(CommandQueueID,
2813                buffer.MemID,
2814                (uint)(blocking_read ? Bool.TRUE : Bool.FALSE),
2815                pBufferOffset,
2816                pHostOffset,
2817                pRegion,
2818                buffer_row_pitch,
2819                buffer_slice_pitch,
2820                host_row_pitch,
2821                host_slice_pitch,
2822                ptr.ToPointer(),
2823                num_events_in_wait_list,
2824                pRepackedEvents,
2825                null);
2826            if (result != ErrorCode.SUCCESS)
2827                throw new OpenCLException("EnqueueReadBufferRect failed with error code " + result, result);
2828        }
2829
2830        public void EnqueueReadBufferRect( Mem buffer,
2831                                bool blocking_read,
2832                                IntPtr[] buffer_offset,
2833                                IntPtr[] host_offset,
2834                                IntPtr[] region,
2835                                IntPtr buffer_row_pitch,
2836                                IntPtr buffer_slice_pitch,
2837                                IntPtr host_row_pitch,
2838                                IntPtr host_slice_pitch,
2839                                IntPtr ptr)
2840        {
2841            ErrorCode result;
2842
2843            result = OpenCL.EnqueueReadBufferRect(CommandQueueID,
2844                buffer.MemID,
2845                (uint)(blocking_read ? Bool.TRUE : Bool.FALSE),
2846                buffer_offset,
2847                host_offset,
2848                region,
2849                buffer_row_pitch,
2850                buffer_slice_pitch,
2851                host_row_pitch,
2852                host_slice_pitch,
2853                ptr.ToPointer(),
2854                0,
2855                null,
2856                null);
2857            if (result != ErrorCode.SUCCESS)
2858                throw new OpenCLException("EnqueueReadBufferRect failed with error code " + result, result);
2859        }
2860        public void EnqueueReadBufferRect(Mem buffer, bool blocking_read, int[] buffer_offset, int[] host_offset, int[] region, int buffer_row_pitch, int buffer_slice_pitch, int host_row_pitch, int host_slice_pitch, IntPtr ptr)
2861        {
2862            ErrorCode result;
2863            IntPtr* pBufferOffset = stackalloc IntPtr[3];
2864            IntPtr* pHostOffset = stackalloc IntPtr[3];
2865            IntPtr* pRegion = stackalloc IntPtr[3];
2866
2867            InteropTools.A3ToIntPtr3(buffer_offset, pBufferOffset);
2868            InteropTools.A3ToIntPtr3(host_offset, pHostOffset);
2869            InteropTools.A3ToIntPtr3(region, pRegion);
2870
2871            result = OpenCL.EnqueueReadBufferRect(CommandQueueID,
2872                buffer.MemID,
2873                (uint)(blocking_read ? Bool.TRUE : Bool.FALSE),
2874                pBufferOffset,
2875                pHostOffset,
2876                pRegion,
2877                buffer_row_pitch,
2878                buffer_slice_pitch,
2879                host_row_pitch,
2880                host_slice_pitch,
2881                ptr.ToPointer(),
2882                0,
2883                null,
2884                null);
2885            if (result != ErrorCode.SUCCESS)
2886                throw new OpenCLException("EnqueueReadBufferRect failed with error code " + result, result);
2887        }
2888        public void EnqueueReadBufferRect(Mem buffer, bool blocking_read, long[] buffer_offset, long[] host_offset, long[] region, long buffer_row_pitch, long buffer_slice_pitch, long host_row_pitch, long host_slice_pitch, IntPtr ptr)
2889        {
2890            ErrorCode result;
2891            IntPtr* pBufferOffset = stackalloc IntPtr[3];
2892            IntPtr* pHostOffset = stackalloc IntPtr[3];
2893            IntPtr* pRegion = stackalloc IntPtr[3];
2894
2895            InteropTools.A3ToIntPtr3(buffer_offset, pBufferOffset);
2896            InteropTools.A3ToIntPtr3(host_offset, pHostOffset);
2897            InteropTools.A3ToIntPtr3(region, pRegion);
2898
2899            result = OpenCL.EnqueueReadBufferRect(CommandQueueID,
2900                buffer.MemID,
2901                (uint)(blocking_read ? Bool.TRUE : Bool.FALSE),
2902                pBufferOffset,
2903                pHostOffset,
2904                pRegion,
2905                buffer_row_pitch,
2906                buffer_slice_pitch,
2907                host_row_pitch,
2908                host_slice_pitch,
2909                ptr.ToPointer(),
2910                0,
2911                null,
2912                null);
2913            if (result != ErrorCode.SUCCESS)
2914                throw new OpenCLException("EnqueueReadBufferRect failed with error code " + result, result);
2915        }
2916
2917        #endregion
2918       
2919        #region EnqueueWriteBufferRect
2920
2921        /// <summary>
2922        /// OpenCL 1.1
2923        /// </summary>
2924        /// <param name="buffer"></param>
2925        /// <param name="blocking_write"></param>
2926        /// <param name="buffer_offset"></param>
2927        /// <param name="host_offset"></param>
2928        /// <param name="region"></param>
2929        /// <param name="buffer_row_pitch"></param>
2930        /// <param name="buffer_slice_pitch"></param>
2931        /// <param name="host_row_pitch"></param>
2932        /// <param name="host_slice_pitch"></param>
2933        /// <param name="ptr"></param>
2934        /// <param name="num_events_in_wait_list"></param>
2935        /// <param name="event_wait_list"></param>
2936        /// <param name="_event"></param>
2937        public void EnqueueWriteBufferRect(Mem buffer,
2938                                 bool blocking_write,
2939                                 IntPtr[] buffer_offset,
2940                                 IntPtr[] host_offset,
2941                                 IntPtr[] region,
2942                                 IntPtr buffer_row_pitch,
2943                                 IntPtr buffer_slice_pitch,
2944                                 IntPtr host_row_pitch,
2945                                 IntPtr host_slice_pitch,
2946                                 IntPtr ptr,
2947                                 uint num_events_in_wait_list,
2948                                 Event[] event_wait_list,
2949                                 out Event _event)
2950        {
2951            ErrorCode result;
2952            IntPtr tmpEvent;
2953
2954            result = OpenCL.EnqueueWriteBufferRect(CommandQueueID,
2955                buffer.MemID,
2956                blocking_write ? 1u : 0u,
2957                buffer_offset,
2958                host_offset,
2959                region,
2960                buffer_row_pitch,
2961                buffer_slice_pitch,
2962                host_row_pitch,
2963                host_slice_pitch,
2964                ptr.ToPointer(),
2965                num_events_in_wait_list,
2966                InteropTools.ConvertEventsToEventIDs(event_wait_list),
2967                &tmpEvent);
2968            _event = new Event(Context, this, tmpEvent);
2969            if (result != ErrorCode.SUCCESS)
2970                throw new OpenCLException("EnqueueWriteBufferRect failed with error code " + result, result);
2971        }
2972        public void EnqueueWriteBufferRect(Mem buffer, bool blocking_write, int[] buffer_offset, int[] host_offset, int[] region, int buffer_row_pitch, int buffer_slice_pitch, int host_row_pitch, int host_slice_pitch, IntPtr ptr, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
2973        {
2974            ErrorCode result;
2975            IntPtr tmpEvent;
2976            IntPtr* pBufferOffset = stackalloc IntPtr[3];
2977            IntPtr* pHostOffset = stackalloc IntPtr[3];
2978            IntPtr* pRegion = stackalloc IntPtr[3];
2979            IntPtr* pRepackedEvents = stackalloc IntPtr[num_events_in_wait_list];
2980
2981            if (num_events_in_wait_list == 0)
2982                pRepackedEvents = null;
2983            InteropTools.A3ToIntPtr3(buffer_offset, pBufferOffset);
2984            InteropTools.A3ToIntPtr3(host_offset, pHostOffset);
2985            InteropTools.A3ToIntPtr3(region, pRegion);
2986            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, pRepackedEvents);
2987
2988            result = OpenCL.EnqueueWriteBufferRect(CommandQueueID,
2989                buffer.MemID,
2990                (uint)(blocking_write ? Bool.TRUE : Bool.FALSE),
2991                pBufferOffset,
2992                pHostOffset,
2993                pRegion,
2994                buffer_row_pitch,
2995                buffer_slice_pitch,
2996                host_row_pitch,
2997                host_slice_pitch,
2998                ptr.ToPointer(),
2999                num_events_in_wait_list,
3000                pRepackedEvents,
3001                &tmpEvent);
3002            _event = new Event(Context, this, tmpEvent);
3003            if (result != ErrorCode.SUCCESS)
3004                throw new OpenCLException("EnqueueWriteBufferRect failed with error code " + result, result);
3005        }
3006        public void EnqueueWriteBufferRect(Mem buffer, bool blocking_write, long[] buffer_offset, long[] host_offset, long[] region, long buffer_row_pitch, long buffer_slice_pitch, long host_row_pitch, long host_slice_pitch, IntPtr ptr, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
3007        {
3008            ErrorCode result;
3009            IntPtr tmpEvent;
3010            IntPtr* pBufferOffset = stackalloc IntPtr[3];
3011            IntPtr* pHostOffset = stackalloc IntPtr[3];
3012            IntPtr* pRegion = stackalloc IntPtr[3];
3013            IntPtr* pRepackedEvents = stackalloc IntPtr[num_events_in_wait_list];
3014
3015            if (num_events_in_wait_list == 0)
3016                pRepackedEvents = null;
3017            InteropTools.A3ToIntPtr3(buffer_offset, pBufferOffset);
3018            InteropTools.A3ToIntPtr3(host_offset, pHostOffset);
3019            InteropTools.A3ToIntPtr3(region, pRegion);
3020            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, pRepackedEvents);
3021
3022            result = OpenCL.EnqueueWriteBufferRect(CommandQueueID,
3023                buffer.MemID,
3024                (uint)(blocking_write ? Bool.TRUE : Bool.FALSE),
3025                pBufferOffset,
3026                pHostOffset,
3027                pRegion,
3028                buffer_row_pitch,
3029                buffer_slice_pitch,
3030                host_row_pitch,
3031                host_slice_pitch,
3032                ptr.ToPointer(),
3033                num_events_in_wait_list,
3034                pRepackedEvents,
3035                &tmpEvent);
3036            _event = new Event(Context, this, tmpEvent);
3037            if (result != ErrorCode.SUCCESS)
3038                throw new OpenCLException("EnqueueWriteBufferRect failed with error code " + result, result);
3039        }
3040
3041        public void EnqueueWriteBufferRect(Mem buffer,
3042                                 bool blocking_write,
3043                                 IntPtr[] buffer_offset,
3044                                 IntPtr[] host_offset,
3045                                 IntPtr[] region,
3046                                 IntPtr buffer_row_pitch,
3047                                 IntPtr buffer_slice_pitch,
3048                                 IntPtr host_row_pitch,
3049                                 IntPtr host_slice_pitch,
3050                                 IntPtr ptr,
3051                                 uint num_events_in_wait_list,
3052                                 Event[] event_wait_list)
3053        {
3054            ErrorCode result;
3055
3056            result = OpenCL.EnqueueWriteBufferRect(CommandQueueID,
3057                buffer.MemID,
3058                blocking_write ? 1u : 0u,
3059                buffer_offset,
3060                host_offset,
3061                region,
3062                buffer_row_pitch,
3063                buffer_slice_pitch,
3064                host_row_pitch,
3065                host_slice_pitch,
3066                ptr.ToPointer(),
3067                num_events_in_wait_list,
3068                InteropTools.ConvertEventsToEventIDs(event_wait_list),
3069                null);
3070
3071            if (result != ErrorCode.SUCCESS)
3072                throw new OpenCLException("EnqueueWriteBufferRect failed with error code " + result, result);
3073        }
3074        public void EnqueueWriteBufferRect(Mem buffer, bool blocking_write, int[] buffer_offset, int[] host_offset, int[] region, int buffer_row_pitch, int buffer_slice_pitch, int host_row_pitch, int host_slice_pitch, IntPtr ptr, int num_events_in_wait_list, Event[] event_wait_list)
3075        {
3076            ErrorCode result;
3077            IntPtr* pBufferOffset = stackalloc IntPtr[3];
3078            IntPtr* pHostOffset = stackalloc IntPtr[3];
3079            IntPtr* pRegion = stackalloc IntPtr[3];
3080            IntPtr* pRepackedEvents = stackalloc IntPtr[num_events_in_wait_list];
3081
3082            if (num_events_in_wait_list == 0)
3083                pRepackedEvents = null;
3084            InteropTools.A3ToIntPtr3(buffer_offset, pBufferOffset);
3085            InteropTools.A3ToIntPtr3(host_offset, pHostOffset);
3086            InteropTools.A3ToIntPtr3(region, pRegion);
3087            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, pRepackedEvents);
3088
3089            result = OpenCL.EnqueueWriteBufferRect(CommandQueueID,
3090                buffer.MemID,
3091                (uint)(blocking_write ? Bool.TRUE : Bool.FALSE),
3092                pBufferOffset,
3093                pHostOffset,
3094                pRegion,
3095                buffer_row_pitch,
3096                buffer_slice_pitch,
3097                host_row_pitch,
3098                host_slice_pitch,
3099                ptr.ToPointer(),
3100                num_events_in_wait_list,
3101                pRepackedEvents,
3102                null);
3103            if (result != ErrorCode.SUCCESS)
3104                throw new OpenCLException("EnqueueWriteBufferRect failed with error code " + result, result);
3105        }
3106        public void EnqueueWriteBufferRect(Mem buffer, bool blocking_write, long[] buffer_offset, long[] host_offset, long[] region, long buffer_row_pitch, long buffer_slice_pitch, long host_row_pitch, long host_slice_pitch, IntPtr ptr, int num_events_in_wait_list, Event[] event_wait_list)
3107        {
3108            ErrorCode result;
3109            IntPtr* pBufferOffset = stackalloc IntPtr[3];
3110            IntPtr* pHostOffset = stackalloc IntPtr[3];
3111            IntPtr* pRegion = stackalloc IntPtr[3];
3112            IntPtr* pRepackedEvents = stackalloc IntPtr[num_events_in_wait_list];
3113
3114            if (num_events_in_wait_list == 0)
3115                pRepackedEvents = null;
3116            InteropTools.A3ToIntPtr3(buffer_offset, pBufferOffset);
3117            InteropTools.A3ToIntPtr3(host_offset, pHostOffset);
3118            InteropTools.A3ToIntPtr3(region, pRegion);
3119            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, pRepackedEvents);
3120
3121            result = OpenCL.EnqueueWriteBufferRect(CommandQueueID,
3122                buffer.MemID,
3123                (uint)(blocking_write ? Bool.TRUE : Bool.FALSE),
3124                pBufferOffset,
3125                pHostOffset,
3126                pRegion,
3127                buffer_row_pitch,
3128                buffer_slice_pitch,
3129                host_row_pitch,
3130                host_slice_pitch,
3131                ptr.ToPointer(),
3132                num_events_in_wait_list,
3133                pRepackedEvents,
3134                null);
3135            if (result != ErrorCode.SUCCESS)
3136                throw new OpenCLException("EnqueueWriteBufferRect failed with error code " + result, result);
3137        }
3138
3139        public void EnqueueWriteBufferRect(Mem buffer,
3140                                 bool blocking_write,
3141                                 IntPtr[] buffer_offset,
3142                                 IntPtr[] host_offset,
3143                                 IntPtr[] region,
3144                                 IntPtr buffer_row_pitch,
3145                                 IntPtr buffer_slice_pitch,
3146                                 IntPtr host_row_pitch,
3147                                 IntPtr host_slice_pitch,
3148                                 IntPtr ptr)
3149        {
3150            ErrorCode result;
3151
3152            result = OpenCL.EnqueueWriteBufferRect(CommandQueueID,
3153                buffer.MemID,
3154                blocking_write ? 1u : 0u,
3155                buffer_offset,
3156                host_offset,
3157                region,
3158                buffer_row_pitch,
3159                buffer_slice_pitch,
3160                host_row_pitch,
3161                host_slice_pitch,
3162                ptr.ToPointer(),
3163                0,
3164                null,
3165                null);
3166            if (result != ErrorCode.SUCCESS)
3167                throw new OpenCLException("EnqueueWriteBufferRect failed with error code " + result, result);
3168        }
3169        public void EnqueueWriteBufferRect(Mem buffer, bool blocking_write, int[] buffer_offset, int[] host_offset, int[] region, int buffer_row_pitch, int buffer_slice_pitch, int host_row_pitch, int host_slice_pitch, IntPtr ptr)
3170        {
3171            ErrorCode result;
3172            IntPtr* pBufferOffset = stackalloc IntPtr[3];
3173            IntPtr* pHostOffset = stackalloc IntPtr[3];
3174            IntPtr* pRegion = stackalloc IntPtr[3];
3175
3176            InteropTools.A3ToIntPtr3(buffer_offset, pBufferOffset);
3177            InteropTools.A3ToIntPtr3(host_offset, pHostOffset);
3178            InteropTools.A3ToIntPtr3(region, pRegion);
3179
3180            result = OpenCL.EnqueueWriteBufferRect(CommandQueueID,
3181                buffer.MemID,
3182                (uint)(blocking_write ? Bool.TRUE : Bool.FALSE),
3183                pBufferOffset,
3184                pHostOffset,
3185                pRegion,
3186                buffer_row_pitch,
3187                buffer_slice_pitch,
3188                host_row_pitch,
3189                host_slice_pitch,
3190                ptr.ToPointer(),
3191                0,
3192                null,
3193                null);
3194            if (result != ErrorCode.SUCCESS)
3195                throw new OpenCLException("EnqueueWriteBufferRect failed with error code " + result, result);
3196        }
3197        public void EnqueueWriteBufferRect(Mem buffer, bool blocking_write, long[] buffer_offset, long[] host_offset, long[] region, long buffer_row_pitch, long buffer_slice_pitch, long host_row_pitch, long host_slice_pitch, IntPtr ptr)
3198        {
3199            ErrorCode result;
3200            IntPtr* pBufferOffset = stackalloc IntPtr[3];
3201            IntPtr* pHostOffset = stackalloc IntPtr[3];
3202            IntPtr* pRegion = stackalloc IntPtr[3];
3203
3204            InteropTools.A3ToIntPtr3(buffer_offset, pBufferOffset);
3205            InteropTools.A3ToIntPtr3(host_offset, pHostOffset);
3206            InteropTools.A3ToIntPtr3(region, pRegion);
3207
3208            result = OpenCL.EnqueueWriteBufferRect(CommandQueueID,
3209                buffer.MemID,
3210                (uint)(blocking_write ? Bool.TRUE : Bool.FALSE),
3211                pBufferOffset,
3212                pHostOffset,
3213                pRegion,
3214                buffer_row_pitch,
3215                buffer_slice_pitch,
3216                host_row_pitch,
3217                host_slice_pitch,
3218                ptr.ToPointer(),
3219                0,
3220                null,
3221                null);
3222            if (result != ErrorCode.SUCCESS)
3223                throw new OpenCLException("EnqueueWriteBufferRect failed with error code " + result, result);
3224        }
3225
3226        #endregion
3227
3228        #region EnqueueCopyBufferRect
3229
3230        /// <summary>
3231        /// OpenCL 1.1
3232        /// </summary>
3233        /// <param name="src_buffer"></param>
3234        /// <param name="dst_buffer"></param>
3235        /// <param name="src_origin"></param>
3236        /// <param name="dst_origin"></param>
3237        /// <param name="region"></param>
3238        /// <param name="src_row_pitch"></param>
3239        /// <param name="src_slice_pitch"></param>
3240        /// <param name="dst_row_pitch"></param>
3241        /// <param name="dst_slice_pitch"></param>
3242        /// <param name="num_events_in_wait_list"></param>
3243        /// <param name="event_wait_list"></param>
3244        /// <param name="_event"></param>
3245        public void EnqueueCopyBufferRect( Mem src_buffer,
3246                                Mem dst_buffer,
3247                                IntPtr[] src_origin,
3248                                IntPtr[] dst_origin,
3249                                IntPtr[] region,
3250                                IntPtr src_row_pitch,
3251                                IntPtr src_slice_pitch,
3252                                IntPtr dst_row_pitch,
3253                                IntPtr dst_slice_pitch,
3254                                uint num_events_in_wait_list,
3255                                Event[] event_wait_list,
3256                                out Event _event)
3257        {
3258            ErrorCode result;
3259            IntPtr tmpEvent;
3260
3261            result = OpenCL.EnqueueCopyBufferRect(CommandQueueID,
3262                src_buffer.MemID,
3263                dst_buffer.MemID,
3264                src_origin,
3265                dst_origin,
3266                region,
3267                src_row_pitch,
3268                src_slice_pitch,
3269                dst_row_pitch,
3270                dst_slice_pitch,
3271                num_events_in_wait_list,
3272                InteropTools.ConvertEventsToEventIDs(event_wait_list),
3273                &tmpEvent);
3274            _event = new Event(Context, this, tmpEvent);
3275            if (result != ErrorCode.SUCCESS)
3276                throw new OpenCLException("EnqueueCopyBufferRect failed with error code " + result, result);
3277        }
3278        public void EnqueueCopyBufferRect(Mem src_buffer, Mem dst_buffer, int[] src_origin, int[] dst_origin, int[] region, int src_row_pitch, int src_slice_pitch, int dst_row_pitch, int dst_slice_pitch, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
3279        {
3280            ErrorCode result;
3281            IntPtr tmpEvent;
3282            IntPtr* pSrcOrigin = stackalloc IntPtr[3];
3283            IntPtr* pDstOrigin = stackalloc IntPtr[3];
3284            IntPtr* pRegion = stackalloc IntPtr[3];
3285            IntPtr* pRepackedEvents = stackalloc IntPtr[num_events_in_wait_list];
3286
3287            if (num_events_in_wait_list == 0)
3288                pRepackedEvents = null;
3289            InteropTools.A3ToIntPtr3(src_origin, pSrcOrigin);
3290            InteropTools.A3ToIntPtr3(dst_origin, pDstOrigin);
3291            InteropTools.A3ToIntPtr3(region, pRegion);
3292            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, pRepackedEvents);
3293
3294            result = OpenCL.EnqueueCopyBufferRect(CommandQueueID,
3295                src_buffer.MemID,
3296                dst_buffer.MemID,
3297                pSrcOrigin,
3298                pDstOrigin,
3299                pRegion,
3300                src_row_pitch,
3301                src_slice_pitch,
3302                dst_row_pitch,
3303                dst_slice_pitch,
3304                num_events_in_wait_list,
3305                pRepackedEvents,
3306                &tmpEvent);
3307            _event = new Event(Context, this, tmpEvent);
3308            if (result != ErrorCode.SUCCESS)
3309                throw new OpenCLException("EnqueueCopyBufferRect failed with error code " + result, result);
3310        }
3311        public void EnqueueCopyBufferRect(Mem src_buffer, Mem dst_buffer, long[] src_origin, long[] dst_origin, long[] region, long src_row_pitch, long src_slice_pitch, long dst_row_pitch, long dst_slice_pitch, int num_events_in_wait_list, Event[] event_wait_list, out Event _event)
3312        {
3313            ErrorCode result;
3314            IntPtr tmpEvent;
3315            IntPtr* pSrcOrigin = stackalloc IntPtr[3];
3316            IntPtr* pDstOrigin = stackalloc IntPtr[3];
3317            IntPtr* pRegion = stackalloc IntPtr[3];
3318            IntPtr* pRepackedEvents = stackalloc IntPtr[num_events_in_wait_list];
3319
3320            if (num_events_in_wait_list == 0)
3321                pRepackedEvents = null;
3322            InteropTools.A3ToIntPtr3(src_origin, pSrcOrigin);
3323            InteropTools.A3ToIntPtr3(dst_origin, pDstOrigin);
3324            InteropTools.A3ToIntPtr3(region, pRegion);
3325            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, pRepackedEvents);
3326
3327            result = OpenCL.EnqueueCopyBufferRect(CommandQueueID,
3328                src_buffer.MemID,
3329                dst_buffer.MemID,
3330                pSrcOrigin,
3331                pDstOrigin,
3332                pRegion,
3333                src_row_pitch,
3334                src_slice_pitch,
3335                dst_row_pitch,
3336                dst_slice_pitch,
3337                num_events_in_wait_list,
3338                pRepackedEvents,
3339                &tmpEvent);
3340            _event = new Event(Context, this, tmpEvent);
3341            if (result != ErrorCode.SUCCESS)
3342                throw new OpenCLException("EnqueueCopyBufferRect failed with error code " + result, result);
3343        }
3344
3345        public void EnqueueCopyBufferRect(Mem src_buffer,
3346                                Mem dst_buffer,
3347                                IntPtr[] src_origin,
3348                                IntPtr[] dst_origin,
3349                                IntPtr[] region,
3350                                IntPtr src_row_pitch,
3351                                IntPtr src_slice_pitch,
3352                                IntPtr dst_row_pitch,
3353                                IntPtr dst_slice_pitch,
3354                                uint num_events_in_wait_list,
3355                                Event[] event_wait_list)
3356        {
3357            ErrorCode result;
3358
3359            result = OpenCL.EnqueueCopyBufferRect(CommandQueueID,
3360                src_buffer.MemID,
3361                dst_buffer.MemID,
3362                src_origin,
3363                dst_origin,
3364                region,
3365                src_row_pitch,
3366                src_slice_pitch,
3367                dst_row_pitch,
3368                dst_slice_pitch,
3369                num_events_in_wait_list,
3370                InteropTools.ConvertEventsToEventIDs(event_wait_list),
3371                null);
3372            if (result != ErrorCode.SUCCESS)
3373                throw new OpenCLException("EnqueueCopyBufferRect failed with error code " + result, result);
3374        }
3375        public void EnqueueCopyBufferRect(Mem src_buffer, Mem dst_buffer, int[] src_origin, int[] dst_origin, int[] region, int src_row_pitch, int src_slice_pitch, int dst_row_pitch, int dst_slice_pitch, int num_events_in_wait_list, Event[] event_wait_list)
3376        {
3377            ErrorCode result;
3378            IntPtr* pSrcOrigin = stackalloc IntPtr[3];
3379            IntPtr* pDstOrigin = stackalloc IntPtr[3];
3380            IntPtr* pRegion = stackalloc IntPtr[3];
3381            IntPtr* pRepackedEvents = stackalloc IntPtr[num_events_in_wait_list];
3382
3383            if (num_events_in_wait_list == 0)
3384                pRepackedEvents = null;
3385            InteropTools.A3ToIntPtr3(src_origin, pSrcOrigin);
3386            InteropTools.A3ToIntPtr3(dst_origin, pDstOrigin);
3387            InteropTools.A3ToIntPtr3(region, pRegion);
3388            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, pRepackedEvents);
3389
3390            result = OpenCL.EnqueueCopyBufferRect(CommandQueueID,
3391                src_buffer.MemID,
3392                dst_buffer.MemID,
3393                pSrcOrigin,
3394                pDstOrigin,
3395                pRegion,
3396                src_row_pitch,
3397                src_slice_pitch,
3398                dst_row_pitch,
3399                dst_slice_pitch,
3400                num_events_in_wait_list,
3401                pRepackedEvents,
3402                null);
3403            if (result != ErrorCode.SUCCESS)
3404                throw new OpenCLException("EnqueueCopyBufferRect failed with error code " + result, result);
3405        }
3406        public void EnqueueCopyBufferRect(Mem src_buffer, Mem dst_buffer, long[] src_origin, long[] dst_origin, long[] region, long src_row_pitch, long src_slice_pitch, long dst_row_pitch, long dst_slice_pitch, int num_events_in_wait_list, Event[] event_wait_list)
3407        {
3408            ErrorCode result;
3409            IntPtr* pSrcOrigin = stackalloc IntPtr[3];
3410            IntPtr* pDstOrigin = stackalloc IntPtr[3];
3411            IntPtr* pRegion = stackalloc IntPtr[3];
3412            IntPtr* pRepackedEvents = stackalloc IntPtr[num_events_in_wait_list];
3413
3414            if (num_events_in_wait_list == 0)
3415                pRepackedEvents = null;
3416            InteropTools.A3ToIntPtr3(src_origin, pSrcOrigin);
3417            InteropTools.A3ToIntPtr3(dst_origin, pDstOrigin);
3418            InteropTools.A3ToIntPtr3(region, pRegion);
3419            InteropTools.ConvertEventsToEventIDs(num_events_in_wait_list, event_wait_list, pRepackedEvents);
3420
3421            result = OpenCL.EnqueueCopyBufferRect(CommandQueueID,
3422                src_buffer.MemID,
3423                dst_buffer.MemID,
3424                pSrcOrigin,
3425                pDstOrigin,
3426                pRegion,
3427                src_row_pitch,
3428                src_slice_pitch,
3429                dst_row_pitch,
3430                dst_slice_pitch,
3431                num_events_in_wait_list,
3432                pRepackedEvents,
3433                null);
3434            if (result != ErrorCode.SUCCESS)
3435                throw new OpenCLException("EnqueueCopyBufferRect failed with error code " + result, result);
3436        }
3437
3438        public void EnqueueCopyBufferRect(Mem src_buffer,
3439                                Mem dst_buffer,
3440                                IntPtr[] src_origin,
3441                                IntPtr[] dst_origin,
3442                                IntPtr[] region,
3443                                IntPtr src_row_pitch,
3444                                IntPtr src_slice_pitch,
3445                                IntPtr dst_row_pitch,
3446                                IntPtr dst_slice_pitch)
3447        {
3448            ErrorCode result;
3449
3450            result = OpenCL.EnqueueCopyBufferRect(CommandQueueID,
3451                src_buffer.MemID,
3452                dst_buffer.MemID,
3453                src_origin,
3454                dst_origin,
3455                region,
3456                src_row_pitch,
3457                src_slice_pitch,
3458                dst_row_pitch,
3459                dst_slice_pitch,
3460                0,
3461                null,
3462                null);
3463            if (result != ErrorCode.SUCCESS)
3464                throw new OpenCLException("EnqueueCopyBufferRect failed with error code " + result, result);
3465        }
3466        public void EnqueueCopyBufferRect(Mem src_buffer, Mem dst_buffer, int[] src_origin, int[] dst_origin, int[] region, int src_row_pitch, int src_slice_pitch, int dst_row_pitch, int dst_slice_pitch)
3467        {
3468            ErrorCode result;
3469            IntPtr* pSrcOrigin = stackalloc IntPtr[3];
3470            IntPtr* pDstOrigin = stackalloc IntPtr[3];
3471            IntPtr* pRegion = stackalloc IntPtr[3];
3472
3473            InteropTools.A3ToIntPtr3(src_origin, pSrcOrigin);
3474            InteropTools.A3ToIntPtr3(dst_origin, pDstOrigin);
3475            InteropTools.A3ToIntPtr3(region, pRegion);
3476
3477            result = OpenCL.EnqueueCopyBufferRect(CommandQueueID,
3478                src_buffer.MemID,
3479                dst_buffer.MemID,
3480                pSrcOrigin,
3481                pDstOrigin,
3482                pRegion,
3483                src_row_pitch,
3484                src_slice_pitch,
3485                dst_row_pitch,
3486                dst_slice_pitch,
3487                0,
3488                null,
3489                null);
3490            if (result != ErrorCode.SUCCESS)
3491                throw new OpenCLException("EnqueueCopyBufferRect failed with error code " + result, result);
3492        }
3493        public void EnqueueCopyBufferRect(Mem src_buffer, Mem dst_buffer, long[] src_origin, long[] dst_origin, long[] region, long src_row_pitch, long src_slice_pitch, long dst_row_pitch, long dst_slice_pitch)
3494        {
3495            ErrorCode result;
3496            IntPtr* pSrcOrigin = stackalloc IntPtr[3];
3497            IntPtr* pDstOrigin = stackalloc IntPtr[3];
3498            IntPtr* pRegion = stackalloc IntPtr[3];
3499
3500            InteropTools.A3ToIntPtr3(src_origin, pSrcOrigin);
3501            InteropTools.A3ToIntPtr3(dst_origin, pDstOrigin);
3502            InteropTools.A3ToIntPtr3(region, pRegion);
3503
3504            result = OpenCL.EnqueueCopyBufferRect(CommandQueueID,
3505                src_buffer.MemID,
3506                dst_buffer.MemID,
3507                pSrcOrigin,
3508                pDstOrigin,
3509                pRegion,
3510                src_row_pitch,
3511                src_slice_pitch,
3512                dst_row_pitch,
3513                dst_slice_pitch,
3514                0,
3515                null,
3516                null);
3517            if (result != ErrorCode.SUCCESS)
3518                throw new OpenCLException("EnqueueCopyBufferRect failed with error code " + result, result);
3519        }
3520
3521        #endregion
3522
3523        public static implicit operator IntPtr( CommandQueue cq )
3524        {
3525            return cq.CommandQueueID;
3526        }
3527    }
3528}
Note: See TracBrowser for help on using the repository browser.