source: trunk/CrypPlugins/Libs/OpenCLNet/Kernel.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: 41.5 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;
32
33namespace OpenCLNet
34{
35    /// <summary>
36    /// The Kernel class wraps an OpenCL kernel handle
37    ///
38    /// The main purposes of this class is to serve as a handle to
39    /// a compiled OpenCL function and to set arguments on the function
40    /// before enqueueing calls.
41    ///
42    /// Arguments are set using either the overloaded SetArg functions or
43    /// explicit Set*Arg functions where * is a type. The most usual types
44    /// are supported, but no vectors. If you need to set a parameter that's
45    /// more advanced than what's supported here, use the version of SetArg
46    /// that takes a pointer and size.
47    ///
48    /// Note that pointer arguments are set by passing their OpenCL memory object,
49    /// not native pointers.
50    /// </summary>
51    unsafe public class Kernel : InteropTools.IPropertyContainer
52    {
53        // Track whether Dispose has been called.
54        private bool disposed = false;
55
56        public string FunctionName { get { return InteropTools.ReadString( this, (uint)KernelInfo.FUNCTION_NAME ); } }
57        public uint NumArgs { get { return InteropTools.ReadUInt( this, (uint)KernelInfo.NUM_ARGS ); } }
58        public uint ReferenceCount { get { return InteropTools.ReadUInt( this, (uint)KernelInfo.REFERENCE_COUNT ); } }
59        public Context Context { get; protected set; }
60        public Program Program { get; protected set; }
61        public IntPtr KernelID { get; set; }
62
63        internal Kernel( Context context, Program program, IntPtr kernelID )
64        {
65            Context = context;
66            Program = program;
67            KernelID = kernelID;
68        }
69
70        ~Kernel()
71        {
72            Dispose( false );
73        }
74
75        #region IDisposable Members
76
77        // Implement IDisposable.
78        // Do not make this method virtual.
79        // A derived class should not be able to override this method.
80        public void Dispose()
81        {
82            Dispose( true );
83            // This object will be cleaned up by the Dispose method.
84            // Therefore, you should call GC.SupressFinalize to
85            // take this object off the finalization queue
86            // and prevent finalization code for this object
87            // from executing a second time.
88            GC.SuppressFinalize( this );
89        }
90
91        // Dispose(bool disposing) executes in two distinct scenarios.
92        // If disposing equals true, the method has been called directly
93        // or indirectly by a user's code. Managed and unmanaged resources
94        // can be disposed.
95        // If disposing equals false, the method has been called by the
96        // runtime from inside the finalizer and you should not reference
97        // other objects. Only unmanaged resources can be disposed.
98        private void Dispose( bool disposing )
99        {
100            // Check to see if Dispose has already been called.
101            if( !this.disposed )
102            {
103                // If disposing equals true, dispose all managed
104                // and unmanaged resources.
105                if( disposing )
106                {
107                    // Dispose managed resources.
108                }
109
110                // Call the appropriate methods to clean up
111                // unmanaged resources here.
112                // If disposing is false,
113                // only the following code is executed.
114                OpenCL.ReleaseKernel( KernelID );
115                KernelID = IntPtr.Zero;
116
117                // Note disposing has been done.
118                disposed = true;
119            }
120        }
121
122
123        #endregion
124
125        public void SetArg( int argIndex, IntPtr argSize, IntPtr argValue )
126        {
127            ErrorCode result;
128
129            result = (ErrorCode)OpenCL.SetKernelArg( KernelID, (uint)argIndex, argSize, argValue.ToPointer() );
130            if( result!=ErrorCode.SUCCESS )
131                throw new OpenCLException( "SetArg failed with error code "+result, result);
132        }
133
134        #region SetArg functions
135
136        /// <summary>
137        /// Set argument argIndex to c
138        /// </summary>
139        /// <param name="argIndex"></param>
140        /// <param name="c"></param>
141        public void SetArg(int argIndex, sbyte c)
142        {
143            ErrorCode result;
144
145            result = (ErrorCode)OpenCL.SetKernelArg(KernelID, (uint)argIndex, new IntPtr(sizeof(sbyte)), &c);
146            if (result != ErrorCode.SUCCESS)
147                throw new OpenCLException("SetArg failed with error code " + result, result);
148        }
149
150        /// <summary>
151        /// Set argument argIndex to c
152        /// </summary>
153        /// <param name="argIndex"></param>
154        /// <param name="c"></param>
155        public void SetArg(int argIndex, byte c)
156        {
157            ErrorCode result;
158
159            result = (ErrorCode)OpenCL.SetKernelArg(KernelID, (uint)argIndex, new IntPtr(sizeof(byte)), &c);
160            if (result != ErrorCode.SUCCESS)
161                throw new OpenCLException("SetArg failed with error code " + result, result);
162        }
163
164        /// <summary>
165        /// Set argument argIndex to c
166        /// </summary>
167        /// <param name="argIndex"></param>
168        /// <param name="c"></param>
169        public void SetArg(int argIndex, short c)
170        {
171            ErrorCode result;
172
173            result = (ErrorCode)OpenCL.SetKernelArg(KernelID, (uint)argIndex, new IntPtr(sizeof(short)), &c);
174            if (result != ErrorCode.SUCCESS)
175                throw new OpenCLException("SetArg failed with error code " + result, result);
176        }
177
178        /// <summary>
179        /// Set argument argIndex to c
180        /// </summary>
181        /// <param name="argIndex"></param>
182        /// <param name="c"></param>
183        public void SetArg(int argIndex, ushort c)
184        {
185            ErrorCode result;
186
187            result = (ErrorCode)OpenCL.SetKernelArg(KernelID, (uint)argIndex, new IntPtr(sizeof(ushort)), &c);
188            if (result != ErrorCode.SUCCESS)
189                throw new OpenCLException("SetArg failed with error code " + result, result);
190        }
191
192        /// <summary>
193        /// Set argument argIndex to c
194        /// </summary>
195        /// <param name="argIndex"></param>
196        /// <param name="c"></param>
197        public void SetArg(int argIndex, int c)
198        {
199            ErrorCode result;
200
201            result = (ErrorCode)OpenCL.SetKernelArg(KernelID, (uint)argIndex, new IntPtr(sizeof(int)), &c);
202            if (result != ErrorCode.SUCCESS)
203                throw new OpenCLException("SetArg failed with error code " + result, result);
204        }
205
206        /// <summary>
207        /// Set argument argIndex to c
208        /// </summary>
209        /// <param name="argIndex"></param>
210        /// <param name="c"></param>
211        public void SetArg(int argIndex, uint c)
212        {
213            ErrorCode result;
214
215            result = (ErrorCode)OpenCL.SetKernelArg(KernelID, (uint)argIndex, new IntPtr(sizeof(uint)), &c);
216            if (result != ErrorCode.SUCCESS)
217                throw new OpenCLException("SetArg failed with error code " + result, result);
218        }
219
220        /// <summary>
221        /// Set argument argIndex to c
222        /// </summary>
223        /// <param name="argIndex"></param>
224        /// <param name="c"></param>
225        public void SetArg(int argIndex, long c)
226        {
227            ErrorCode result;
228
229            result = (ErrorCode)OpenCL.SetKernelArg(KernelID, (uint)argIndex, new IntPtr(sizeof(long)), &c);
230            if (result != ErrorCode.SUCCESS)
231                throw new OpenCLException("SetArg failed with error code " + result, result);
232        }
233
234        /// <summary>
235        /// Set argument argIndex to c
236        /// </summary>
237        /// <param name="argIndex"></param>
238        /// <param name="c"></param>
239        public void SetArg(int argIndex, ulong c)
240        {
241            ErrorCode result;
242
243            result = (ErrorCode)OpenCL.SetKernelArg(KernelID, (uint)argIndex, new IntPtr(sizeof(ulong)), &c);
244            if (result != ErrorCode.SUCCESS)
245                throw new OpenCLException("SetArg failed with error code " + result, result);
246        }
247
248        /// <summary>
249        /// Set argument argIndex to c
250        /// </summary>
251        /// <param name="argIndex"></param>
252        /// <param name="c"></param>
253        public void SetArg( int argIndex, float c )
254        {
255            ErrorCode result;
256
257            result = (ErrorCode)OpenCL.SetKernelArg(KernelID, (uint)argIndex, new IntPtr(sizeof(float)), &c);
258            if( result!=ErrorCode.SUCCESS )
259                throw new OpenCLException( "SetArg failed with error code "+result, result);
260        }
261
262        /// <summary>
263        /// Set argument argIndex to c
264        /// </summary>
265        /// <param name="argIndex"></param>
266        /// <param name="c"></param>
267        public void SetArg(int argIndex, double c)
268        {
269            ErrorCode result;
270
271            result = (ErrorCode)OpenCL.SetKernelArg(KernelID, (uint)argIndex, new IntPtr(sizeof(double)), &c);
272            if( result!=ErrorCode.SUCCESS )
273                throw new OpenCLException( "SetArg failed with error code "+result, result);
274        }
275
276        /// <summary>
277        /// Set argument argIndex to c
278        /// </summary>
279        /// <param name="argIndex"></param>
280        /// <param name="c"></param>
281        public void SetArg( int argIndex, IntPtr c )
282        {
283            ErrorCode result;
284            IntPtr lc = c;
285            result = (ErrorCode)OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(IntPtr), &lc);
286            if (result != ErrorCode.SUCCESS)
287                throw new OpenCLException( "SetArg failed with error code "+result, result);
288        }
289
290        /// <summary>
291        /// Set argument argIndex to mem
292        /// </summary>
293        /// <param name="argIndex"></param>
294        /// <param name="mem"></param>
295        public void SetArg(int argIndex, Mem mem)
296        {
297            SetArg(argIndex, mem.MemID);
298        }
299
300        /// <summary>
301        /// Set argument argIndex to sampler
302        /// </summary>
303        /// <param name="argIndex"></param>
304        /// <param name="sampler"></param>
305        public void SetArg(int argIndex, Sampler sampler)
306        {
307            SetArg(argIndex, sampler.SamplerID);
308        }
309
310        #region Vector Set functions
311
312        #region Vector2
313
314        public void SetArg(int argIndex, Char2 c)
315        {
316            ErrorCode result;
317
318            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(Char2), &c);
319            if (result != ErrorCode.SUCCESS)
320                throw new OpenCLException("SetArg failed with error code " + result, result);
321        }
322
323        public void SetArg(int argIndex, UChar2 c)
324        {
325            ErrorCode result;
326
327            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(UChar2), &c);
328            if (result != ErrorCode.SUCCESS)
329                throw new OpenCLException("SetArg failed with error code " + result, result);
330        }
331
332        public void SetArg(int argIndex, Short2 c)
333        {
334            ErrorCode result;
335
336            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(Short2), &c);
337            if (result != ErrorCode.SUCCESS)
338                throw new OpenCLException("SetArg failed with error code " + result, result);
339        }
340
341        public void SetArg(int argIndex, UShort2 c)
342        {
343            ErrorCode result;
344
345            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(UShort2), &c);
346            if (result != ErrorCode.SUCCESS)
347                throw new OpenCLException("SetArg failed with error code " + result, result);
348        }
349
350        public void SetArg(int argIndex, Int2 c)
351        {
352            ErrorCode result;
353
354            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(Int2), &c);
355            if (result != ErrorCode.SUCCESS)
356                throw new OpenCLException("SetArg failed with error code " + result, result);
357        }
358
359        public void SetArg(int argIndex, UInt2 c)
360        {
361            ErrorCode result;
362
363            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(UInt2), &c);
364            if (result != ErrorCode.SUCCESS)
365                throw new OpenCLException("SetArg failed with error code " + result, result);
366        }
367
368        public void SetArg(int argIndex, Long2 c)
369        {
370            ErrorCode result;
371
372            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(Long2), &c);
373            if (result != ErrorCode.SUCCESS)
374                throw new OpenCLException("SetArg failed with error code " + result, result);
375        }
376
377        public void SetArg(int argIndex, ULong2 c)
378        {
379            ErrorCode result;
380
381            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(ULong2), &c);
382            if (result != ErrorCode.SUCCESS)
383                throw new OpenCLException("SetArg failed with error code " + result, result);
384        }
385
386        public void SetArg(int argIndex, Float2 c)
387        {
388            ErrorCode result;
389
390            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(Float2), &c);
391            if (result != ErrorCode.SUCCESS)
392                throw new OpenCLException("SetArg failed with error code " + result, result);
393        }
394
395        public void SetArg(int argIndex, Double2 c)
396        {
397            ErrorCode result;
398
399            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(Double2), &c);
400            if (result != ErrorCode.SUCCESS)
401                throw new OpenCLException("SetArg failed with error code " + result, result);
402        }
403
404        #endregion
405
406        #region Vector3
407
408        public void SetArg(int argIndex, Char3 c)
409        {
410            ErrorCode result;
411
412            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(Char3), &c);
413            if (result != ErrorCode.SUCCESS)
414                throw new OpenCLException("SetArg failed with error code " + result, result);
415        }
416
417        public void SetArg(int argIndex, UChar3 c)
418        {
419            ErrorCode result;
420
421            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(UChar3), &c);
422            if (result != ErrorCode.SUCCESS)
423                throw new OpenCLException("SetArg failed with error code " + result, result);
424        }
425
426        public void SetArg(int argIndex, Short3 c)
427        {
428            ErrorCode result;
429
430            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(Short3), &c);
431            if (result != ErrorCode.SUCCESS)
432                throw new OpenCLException("SetArg failed with error code " + result, result);
433        }
434
435        public void SetArg(int argIndex, UShort3 c)
436        {
437            ErrorCode result;
438
439            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(UShort3), &c);
440            if (result != ErrorCode.SUCCESS)
441                throw new OpenCLException("SetArg failed with error code " + result, result);
442        }
443
444        public void SetArg(int argIndex, Int3 c)
445        {
446            ErrorCode result;
447
448            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(Int3), &c);
449            if (result != ErrorCode.SUCCESS)
450                throw new OpenCLException("SetArg failed with error code " + result, result);
451        }
452
453        public void SetArg(int argIndex, UInt3 c)
454        {
455            ErrorCode result;
456
457            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(UInt3), &c);
458            if (result != ErrorCode.SUCCESS)
459                throw new OpenCLException("SetArg failed with error code " + result, result);
460        }
461
462        public void SetArg(int argIndex, Long3 c)
463        {
464            ErrorCode result;
465
466            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(Long3), &c);
467            if (result != ErrorCode.SUCCESS)
468                throw new OpenCLException("SetArg failed with error code " + result, result);
469        }
470
471        public void SetArg(int argIndex, ULong3 c)
472        {
473            ErrorCode result;
474
475            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(ULong3), &c);
476            if (result != ErrorCode.SUCCESS)
477                throw new OpenCLException("SetArg failed with error code " + result, result);
478        }
479
480        public void SetArg(int argIndex, Float3 c)
481        {
482            ErrorCode result;
483
484            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(Float3), &c);
485            if (result != ErrorCode.SUCCESS)
486                throw new OpenCLException("SetArg failed with error code " + result, result);
487        }
488
489        public void SetArg(int argIndex, Double3 c)
490        {
491            ErrorCode result;
492
493            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(Double3), &c);
494            if (result != ErrorCode.SUCCESS)
495                throw new OpenCLException("SetArg failed with error code " + result, result);
496        }
497
498        #endregion
499
500        #region Vector4
501
502        public void SetArg(int argIndex, Char4 c)
503        {
504            ErrorCode result;
505
506            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(Char4), &c);
507            if (result != ErrorCode.SUCCESS)
508                throw new OpenCLException("SetArg failed with error code " + result, result);
509        }
510
511        public void SetArg(int argIndex, UChar4 c)
512        {
513            ErrorCode result;
514
515            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(UChar4), &c);
516            if (result != ErrorCode.SUCCESS)
517                throw new OpenCLException("SetArg failed with error code " + result, result);
518        }
519
520        public void SetArg(int argIndex, Short4 c)
521        {
522            ErrorCode result;
523
524            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(Short4), &c);
525            if (result != ErrorCode.SUCCESS)
526                throw new OpenCLException("SetArg failed with error code " + result, result);
527        }
528
529        public void SetArg(int argIndex, UShort4 c)
530        {
531            ErrorCode result;
532
533            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(UShort4), &c);
534            if (result != ErrorCode.SUCCESS)
535                throw new OpenCLException("SetArg failed with error code " + result, result);
536        }
537
538        public void SetArg(int argIndex, Int4 c)
539        {
540            ErrorCode result;
541
542            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(Int4), &c);
543            if (result != ErrorCode.SUCCESS)
544                throw new OpenCLException("SetArg failed with error code " + result, result);
545        }
546
547        public void SetArg(int argIndex, UInt4 c)
548        {
549            ErrorCode result;
550
551            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(UInt4), &c);
552            if (result != ErrorCode.SUCCESS)
553                throw new OpenCLException("SetArg failed with error code " + result, result);
554        }
555
556        public void SetArg(int argIndex, Long4 c)
557        {
558            ErrorCode result;
559
560            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(Long4), &c);
561            if (result != ErrorCode.SUCCESS)
562                throw new OpenCLException("SetArg failed with error code " + result, result);
563        }
564
565        public void SetArg(int argIndex, ULong4 c)
566        {
567            ErrorCode result;
568
569            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(ULong4), &c);
570            if (result != ErrorCode.SUCCESS)
571                throw new OpenCLException("SetArg failed with error code " + result, result);
572        }
573
574        public void SetArg(int argIndex, Float4 c)
575        {
576            ErrorCode result;
577
578            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(Float4), &c);
579            if (result != ErrorCode.SUCCESS)
580                throw new OpenCLException("SetArg failed with error code " + result, result);
581        }
582
583        public void SetArg(int argIndex, Double4 c)
584        {
585            ErrorCode result;
586
587            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(Double4), &c);
588            if (result != ErrorCode.SUCCESS)
589                throw new OpenCLException("SetArg failed with error code " + result, result);
590        }
591
592        #endregion
593
594        #region Vector8
595
596        public void SetArg(int argIndex, Char8 c)
597        {
598            ErrorCode result;
599
600            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(Char8), &c);
601            if (result != ErrorCode.SUCCESS)
602                throw new OpenCLException("SetArg failed with error code " + result, result);
603        }
604
605        public void SetArg(int argIndex, UChar8 c)
606        {
607            ErrorCode result;
608
609            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(UChar8), &c);
610            if (result != ErrorCode.SUCCESS)
611                throw new OpenCLException("SetArg failed with error code " + result, result);
612        }
613
614        public void SetArg(int argIndex, Short8 c)
615        {
616            ErrorCode result;
617
618            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(Short8), &c);
619            if (result != ErrorCode.SUCCESS)
620                throw new OpenCLException("SetArg failed with error code " + result, result);
621        }
622
623        public void SetArg(int argIndex, UShort8 c)
624        {
625            ErrorCode result;
626
627            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(UShort8), &c);
628            if (result != ErrorCode.SUCCESS)
629                throw new OpenCLException("SetArg failed with error code " + result, result);
630        }
631
632        public void SetArg(int argIndex, Int8 c)
633        {
634            ErrorCode result;
635
636            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(Int8), &c);
637            if (result != ErrorCode.SUCCESS)
638                throw new OpenCLException("SetArg failed with error code " + result, result);
639        }
640
641        public void SetArg(int argIndex, UInt8 c)
642        {
643            ErrorCode result;
644
645            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(UInt8), &c);
646            if (result != ErrorCode.SUCCESS)
647                throw new OpenCLException("SetArg failed with error code " + result, result);
648        }
649
650        public void SetArg(int argIndex, Long8 c)
651        {
652            ErrorCode result;
653
654            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(Long8), &c);
655            if (result != ErrorCode.SUCCESS)
656                throw new OpenCLException("SetArg failed with error code " + result, result);
657        }
658
659        public void SetArg(int argIndex, ULong8 c)
660        {
661            ErrorCode result;
662
663            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(ULong8), &c);
664            if (result != ErrorCode.SUCCESS)
665                throw new OpenCLException("SetArg failed with error code " + result, result);
666        }
667
668        public void SetArg(int argIndex, Float8 c)
669        {
670            ErrorCode result;
671
672            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(Float8), &c);
673            if (result != ErrorCode.SUCCESS)
674                throw new OpenCLException("SetArg failed with error code " + result, result);
675        }
676
677        public void SetArg(int argIndex, Double8 c)
678        {
679            ErrorCode result;
680
681            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(Double8), &c);
682            if (result != ErrorCode.SUCCESS)
683                throw new OpenCLException("SetArg failed with error code " + result, result);
684        }
685
686        #endregion
687
688        #region Vector16
689
690        public void SetArg(int argIndex, Char16 c)
691        {
692            ErrorCode result;
693
694            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(Char16), &c);
695            if (result != ErrorCode.SUCCESS)
696                throw new OpenCLException("SetArg failed with error code " + result, result);
697        }
698
699        public void SetArg(int argIndex, UChar16 c)
700        {
701            ErrorCode result;
702
703            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(UChar16), &c);
704            if (result != ErrorCode.SUCCESS)
705                throw new OpenCLException("SetArg failed with error code " + result, result);
706        }
707
708        public void SetArg(int argIndex, Short16 c)
709        {
710            ErrorCode result;
711
712            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(Short16), &c);
713            if (result != ErrorCode.SUCCESS)
714                throw new OpenCLException("SetArg failed with error code " + result, result);
715        }
716
717        public void SetArg(int argIndex, UShort16 c)
718        {
719            ErrorCode result;
720
721            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(UShort16), &c);
722            if (result != ErrorCode.SUCCESS)
723                throw new OpenCLException("SetArg failed with error code " + result, result);
724        }
725
726        public void SetArg(int argIndex, Int16 c)
727        {
728            ErrorCode result;
729
730            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(Int16), &c);
731            if (result != ErrorCode.SUCCESS)
732                throw new OpenCLException("SetArg failed with error code " + result, result);
733        }
734
735        public void SetArg(int argIndex, UInt16 c)
736        {
737            ErrorCode result;
738
739            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(UInt16), &c);
740            if (result != ErrorCode.SUCCESS)
741                throw new OpenCLException("SetArg failed with error code " + result, result);
742        }
743
744        public void SetArg(int argIndex, Long16 c)
745        {
746            ErrorCode result;
747
748            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(Long16), &c);
749            if (result != ErrorCode.SUCCESS)
750                throw new OpenCLException("SetArg failed with error code " + result, result);
751        }
752
753        public void SetArg(int argIndex, ULong16 c)
754        {
755            ErrorCode result;
756
757            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(ULong16), &c);
758            if (result != ErrorCode.SUCCESS)
759                throw new OpenCLException("SetArg failed with error code " + result, result);
760        }
761
762        public void SetArg(int argIndex, Float16 c)
763        {
764            ErrorCode result;
765
766            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(Float16), &c);
767            if (result != ErrorCode.SUCCESS)
768                throw new OpenCLException("SetArg failed with error code " + result, result);
769        }
770
771        public void SetArg(int argIndex, Double16 c)
772        {
773            ErrorCode result;
774
775            result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(Double16), &c);
776            if (result != ErrorCode.SUCCESS)
777                throw new OpenCLException("SetArg failed with error code " + result, result);
778        }
779
780        #endregion
781
782        #endregion
783
784        #endregion
785
786        #region SetSizeTArg
787
788        /// <summary>
789        /// This function will assign a value to a kernel argument of type size_t.
790        /// size_t is 32 bit
791        /// </summary>
792        /// <param name="argIndex"></param>
793        /// <param name="c"></param>
794        public void SetSizeTArg(int argIndex, IntPtr c)
795        {
796            ErrorCode result;
797            if (Context.Is64BitContext)
798            {
799                long l = c.ToInt64();
800                result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, new IntPtr(8), &l);
801            }
802            else
803            {
804                int i = c.ToInt32();
805                result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, new IntPtr(4), &i);
806            }
807            if (result != ErrorCode.SUCCESS)
808                throw new OpenCLException("SetArg failed with error code " + result, result);
809        }
810
811        public void SetSizeTArg(int argIndex, int c)
812        {
813            ErrorCode result;
814            if (Context.Is64BitContext)
815            {
816                long l = (long)c;
817                result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, new IntPtr(8), &l);
818            }
819            else
820            {
821                int i = c;
822                result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, new IntPtr(4), &i);
823            }
824            if (result != ErrorCode.SUCCESS)
825                throw new OpenCLException("SetArg failed with error code " + result, result);
826        }
827
828        public void SetSizeTArg(int argIndex, long c)
829        {
830            ErrorCode result;
831            if (Context.Is64BitContext)
832            {
833                long l = c;
834                result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, new IntPtr(8), &l);
835            }
836            else
837            {
838                int i = (int)c;
839                result = OpenCL.SetKernelArg(KernelID, (uint)argIndex, new IntPtr(4), &i);
840            }
841            if (result != ErrorCode.SUCCESS)
842                throw new OpenCLException("SetArg failed with error code " + result, result);
843        }
844
845        #endregion
846
847        #region Setargs with explicit function names(For VB mostly)
848
849        public void SetSByteArg(int argIndex, sbyte c)
850        {
851            ErrorCode result;
852
853            result = (ErrorCode)OpenCL.SetKernelArg(KernelID, (uint)argIndex, new IntPtr(sizeof(sbyte)), &c);
854            if (result != ErrorCode.SUCCESS)
855                throw new OpenCLException("SetArg failed with error code " + result, result);
856        }
857
858        public void SetByteArg(int argIndex, byte c)
859        {
860            ErrorCode result;
861
862            result = (ErrorCode)OpenCL.SetKernelArg(KernelID, (uint)argIndex, new IntPtr(sizeof(byte)), &c);
863            if (result != ErrorCode.SUCCESS)
864                throw new OpenCLException("SetArg failed with error code " + result, result);
865        }
866
867        public void SetShortArg(int argIndex, short c)
868        {
869            ErrorCode result;
870
871            result = (ErrorCode)OpenCL.SetKernelArg(KernelID, (uint)argIndex, new IntPtr(sizeof(short)), &c);
872            if (result != ErrorCode.SUCCESS)
873                throw new OpenCLException("SetArg failed with error code " + result, result);
874        }
875
876        public void SetUShortArg(int argIndex, ushort c)
877        {
878            ErrorCode result;
879
880            result = (ErrorCode)OpenCL.SetKernelArg(KernelID, (uint)argIndex, new IntPtr(sizeof(ushort)), &c);
881            if (result != ErrorCode.SUCCESS)
882                throw new OpenCLException("SetArg failed with error code " + result, result);
883        }
884
885        public void SetIntArg(int argIndex, int c)
886        {
887            ErrorCode result;
888
889            result = (ErrorCode)OpenCL.SetKernelArg(KernelID, (uint)argIndex, new IntPtr(sizeof(int)), &c);
890            if (result != ErrorCode.SUCCESS)
891                throw new OpenCLException("SetArg failed with error code " + result, result);
892        }
893
894        public void SetUIntArg(int argIndex, uint c)
895        {
896            ErrorCode result;
897
898            result = (ErrorCode)OpenCL.SetKernelArg(KernelID, (uint)argIndex, new IntPtr(sizeof(uint)), &c);
899            if (result != ErrorCode.SUCCESS)
900                throw new OpenCLException("SetArg failed with error code " + result, result);
901        }
902
903        public void SetLongArg(int argIndex, long c)
904        {
905            ErrorCode result;
906
907            result = (ErrorCode)OpenCL.SetKernelArg(KernelID, (uint)argIndex, new IntPtr(sizeof(long)), &c);
908            if (result != ErrorCode.SUCCESS)
909                throw new OpenCLException("SetArg failed with error code " + result, result);
910        }
911
912        public void SetULongArg(int argIndex, ulong c)
913        {
914            ErrorCode result;
915
916            result = (ErrorCode)OpenCL.SetKernelArg(KernelID, (uint)argIndex, new IntPtr(sizeof(ulong)), &c);
917            if (result != ErrorCode.SUCCESS)
918                throw new OpenCLException("SetArg failed with error code " + result, result);
919        }
920
921        public void SetSingleArg(int argIndex, float c)
922        {
923            ErrorCode result;
924
925            result = (ErrorCode)OpenCL.SetKernelArg(KernelID, (uint)argIndex, new IntPtr(sizeof(float)), &c);
926            if (result != ErrorCode.SUCCESS)
927                throw new OpenCLException("SetArg failed with error code " + result, result);
928        }
929
930        public void SetDoubleArg(int argIndex, double c)
931        {
932            ErrorCode result;
933
934            result = (ErrorCode)OpenCL.SetKernelArg(KernelID, (uint)argIndex, new IntPtr(sizeof(double)), &c);
935            if (result != ErrorCode.SUCCESS)
936                throw new OpenCLException("SetArg failed with error code " + result, result);
937        }
938
939        /// <summary>
940        /// Note that this function sets C# IntPtr args that are handles to OpenCL memory objects.
941        /// The OpenCL-C datatype intptr_t is not available to use as a kernel argument.
942        /// Use the type size_t and SetSizeTArg if you need platform specific integer sizes.
943        /// </summary>
944        /// <param name="argIndex"></param>
945        /// <param name="c"></param>
946        public void SetIntPtrArg(int argIndex, IntPtr c)
947        {
948            ErrorCode result;
949            IntPtr lc = c;
950
951            result = (ErrorCode)OpenCL.SetKernelArg(KernelID, (uint)argIndex, (IntPtr)sizeof(IntPtr), &lc);
952            if (result != ErrorCode.SUCCESS)
953                throw new OpenCLException("SetArg failed with error code " + result, result);
954        }
955
956        public void SetMemArg(int argIndex, Mem mem)
957        {
958            SetIntPtrArg(argIndex, mem.MemID);
959        }
960
961        public void SetSamplerArg(int argIndex, Sampler sampler)
962        {
963            SetIntPtrArg(argIndex, sampler.SamplerID);
964        }
965
966        #endregion
967
968#if false
969        // Have to add some endian checking before compiling these into the library
970
971        #region Set Char vectors
972       
973        public void SetChar2Arg(int argIndex, sbyte s0, sbyte s1)
974        {
975            sbyte* pBuffer = stackalloc sbyte[2];
976            pBuffer[0] = s0;
977            pBuffer[1] = s1;
978            SetArg(argIndex, (IntPtr)(sizeof(sbyte) * 2), (IntPtr)pBuffer);
979        }
980
981        public void SetChar4Arg(int argIndex, sbyte s0, sbyte s1, sbyte s2, sbyte s3)
982        {
983            sbyte* pBuffer = stackalloc sbyte[4];
984            pBuffer[0] = s0;
985            pBuffer[1] = s1;
986            pBuffer[2] = s2;
987            pBuffer[3] = s3;
988            SetArg(argIndex, (IntPtr)(sizeof(sbyte) * 4), (IntPtr)pBuffer);
989        }
990
991        #endregion
992       
993        #region Set UChar vectors
994
995        public void SetUChar2Arg(int argIndex, byte s0, byte s1)
996        {
997            byte* pBuffer = stackalloc byte[2];
998            pBuffer[0] = s0;
999            pBuffer[1] = s1;
1000            SetArg(argIndex, (IntPtr)(sizeof(byte) * 2), (IntPtr)pBuffer);
1001        }
1002
1003        public void SetUChar4Arg(int argIndex, byte s0, byte s1, byte s2, byte s3)
1004        {
1005            byte* pBuffer = stackalloc byte[4];
1006            pBuffer[0] = s0;
1007            pBuffer[1] = s1;
1008            pBuffer[2] = s2;
1009            pBuffer[3] = s3;
1010            SetArg(argIndex, (IntPtr)(sizeof(byte) * 4), (IntPtr)pBuffer);
1011        }
1012
1013        #endregion
1014
1015        #region Set Int vectors
1016
1017        public void SetInt2Arg(int argIndex, int s0, int s1)
1018        {
1019            int* pBuffer = stackalloc int[2];
1020            pBuffer[0] = s0;
1021            pBuffer[1] = s1;
1022            SetArg(argIndex, (IntPtr)(sizeof(int) * 2), (IntPtr)pBuffer);
1023        }
1024
1025        public void SetInt4Arg(int argIndex, int s0, int s1, int s2, int s3)
1026        {
1027            int* pBuffer = stackalloc int[4];
1028            pBuffer[0] = s0;
1029            pBuffer[1] = s1;
1030            pBuffer[2] = s2;
1031            pBuffer[3] = s3;
1032            SetArg(argIndex, (IntPtr)(sizeof(int) * 4), (IntPtr)pBuffer);
1033        }
1034
1035        #endregion
1036
1037        #region Set UInt vectors
1038
1039        public void SetUInt2Arg(int argIndex, uint s0, uint s1)
1040        {
1041            uint* pBuffer = stackalloc uint[2];
1042            pBuffer[0] = s0;
1043            pBuffer[1] = s1;
1044            SetArg(argIndex, (IntPtr)(sizeof(uint) * 2), (IntPtr)pBuffer);
1045        }
1046
1047        public void SetUInt4Arg(int argIndex, uint s0, uint s1, uint s2, uint s3)
1048        {
1049            uint* pBuffer = stackalloc uint[4];
1050            pBuffer[0] = s0;
1051            pBuffer[1] = s1;
1052            pBuffer[2] = s2;
1053            pBuffer[3] = s3;
1054            SetArg(argIndex, (IntPtr)(sizeof(uint) * 4), (IntPtr)pBuffer);
1055        }
1056
1057        #endregion
1058
1059        #region Set Long vectors
1060
1061        public void SetLong2Arg(int argIndex, long s0, long s1)
1062        {
1063            long* pBuffer = stackalloc long[2];
1064            pBuffer[0] = s0;
1065            pBuffer[1] = s1;
1066            SetArg(argIndex, (IntPtr)(sizeof(long) * 2), (IntPtr)pBuffer);
1067        }
1068
1069        public void SetLong4Arg(int argIndex, long s0, long s1, long s2, long s3)
1070        {
1071            long* pBuffer = stackalloc long[4];
1072            pBuffer[0] = s0;
1073            pBuffer[1] = s1;
1074            pBuffer[2] = s2;
1075            pBuffer[3] = s3;
1076            SetArg(argIndex, (IntPtr)(sizeof(long) * 4), (IntPtr)pBuffer);
1077        }
1078
1079        #endregion
1080
1081        #region Set ULong vectors
1082
1083        public void SetULong2Arg(int argIndex, ulong s0, ulong s1)
1084        {
1085            ulong* pBuffer = stackalloc ulong[2];
1086            pBuffer[0] = s0;
1087            pBuffer[1] = s1;
1088            SetArg(argIndex, (IntPtr)(sizeof(ulong) * 2), (IntPtr)pBuffer);
1089        }
1090
1091        public void SetULong4Arg(int argIndex, ulong s0, ulong s1, ulong s2, ulong s3)
1092        {
1093            ulong* pBuffer = stackalloc ulong[4];
1094            pBuffer[0] = s0;
1095            pBuffer[1] = s1;
1096            pBuffer[2] = s2;
1097            pBuffer[3] = s3;
1098            SetArg(argIndex, (IntPtr)(sizeof(ulong) * 4), (IntPtr)pBuffer);
1099        }
1100
1101        #endregion
1102
1103        #region Set Float vectors
1104
1105        public void SetFloat2Arg(int argIndex, float s0, float s1)
1106        {
1107            float* pBuffer = stackalloc float[2];
1108            pBuffer[0] = s0;
1109            pBuffer[1] = s1;
1110            SetArg(argIndex, (IntPtr)(sizeof(float) * 2), (IntPtr)pBuffer);
1111        }
1112
1113        public void SetFloat4Arg(int argIndex, float s0, float s1, float s2, float s3)
1114        {
1115            float* pBuffer = stackalloc float[4];
1116            pBuffer[0] = s0;
1117            pBuffer[1] = s1;
1118            pBuffer[2] = s2;
1119            pBuffer[3] = s3;
1120            SetArg(argIndex, (IntPtr)(sizeof(float) * 4), (IntPtr)pBuffer);
1121        }
1122
1123        #endregion
1124
1125#endif
1126        public static implicit operator IntPtr( Kernel k )
1127        {
1128            return k.KernelID;
1129        }
1130
1131        #region IPropertyContainer Members
1132
1133        public IntPtr GetPropertySize( uint key )
1134        {
1135            IntPtr size;
1136            ErrorCode result;
1137
1138            result = (ErrorCode)OpenCL.GetKernelInfo( KernelID, key, IntPtr.Zero, null, out size );
1139            if( result!=ErrorCode.SUCCESS )
1140                throw new OpenCLException( "Unable to get kernel info for kernel "+KernelID, result);
1141            return size;
1142        }
1143
1144        public void ReadProperty( uint key, IntPtr keyLength, void* pBuffer )
1145        {
1146            IntPtr size;
1147            ErrorCode result;
1148
1149            result = (ErrorCode)OpenCL.GetKernelInfo( KernelID, (uint)key, keyLength, pBuffer, out size );
1150            if( result!=(int)ErrorCode.SUCCESS )
1151                throw new OpenCLException( "Unable to get kernel info for kernel "+KernelID, result);
1152        }
1153
1154        #endregion
1155    }
1156}
Note: See TracBrowser for help on using the repository browser.