source: trunk/CrypPlugins/Libs/OpenCLNet/AlignedArray.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: 12.2 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;
31
32namespace OpenCLNet
33{
34
35    unsafe public class AlignedArray<T> where T : struct
36    {
37        protected IntPtr UnmanagedMemory;
38        protected IntPtr AlignedMemory;
39
40        public long Length { get; protected set; }
41        public long ByteLength { get; protected set; }
42        protected long   ByteAlignment;
43        protected long   AlignedArraySize;
44        protected int    TStride = Marshal.SizeOf( typeof( T ) );
45
46        // Track whether Dispose has been called.
47        private bool disposed = false;
48
49        public AlignedArray( long size, long byteAlignment )
50        {
51            long alignmentMask;
52
53            Length = size;
54            ByteLength = size*TStride;
55            AlignedArraySize = size*TStride;
56            ByteAlignment = byteAlignment;
57            UnmanagedMemory = Marshal.AllocHGlobal( new IntPtr( AlignedArraySize+byteAlignment-1 ) );
58            alignmentMask = ByteAlignment-1;
59            AlignedMemory = new IntPtr( (UnmanagedMemory.ToInt64()+byteAlignment-1)&~alignmentMask );
60        }
61
62        ~AlignedArray()
63        {
64            Dispose( false );
65        }
66
67        #region IDisposable Members
68
69        // Implement IDisposable.
70        // Do not make this method virtual.
71        // A derived class should not be able to override this method.
72        public void Dispose()
73        {
74            Dispose( true );
75            // This object will be cleaned up by the Dispose method.
76            // Therefore, you should call GC.SupressFinalize to
77            // take this object off the finalization queue
78            // and prevent finalization code for this object
79            // from executing a second time.
80            GC.SuppressFinalize( this );
81        }
82
83        // Dispose(bool disposing) executes in two distinct scenarios.
84        // If disposing equals true, the method has been called directly
85        // or indirectly by a user's code. Managed and unmanaged resources
86        // can be disposed.
87        // If disposing equals false, the method has been called by the
88        // runtime from inside the finalizer and you should not reference
89        // other objects. Only unmanaged resources can be disposed.
90        private void Dispose( bool disposing )
91        {
92            // Check to see if Dispose has already been called.
93            if( !this.disposed )
94            {
95                // If disposing equals true, dispose all managed
96                // and unmanaged resources.
97                if( disposing )
98                {
99                    // Dispose managed resources.
100                }
101
102                // Call the appropriate methods to clean up
103                // unmanaged resources here.
104                // If disposing is false,
105                // only the following code is executed.
106                Marshal.FreeHGlobal( UnmanagedMemory );
107
108                // Note disposing has been done.
109                disposed = true;
110            }
111        }
112
113        #endregion
114    }
115
116
117    #region AlignedArrayByte
118
119    /// <summary>
120    /// Aligned 1D array class for bytes
121    /// </summary>
122    unsafe public class AlignedArrayByte : AlignedArray<byte>
123    {
124        byte* pAlignedArray;
125
126        public AlignedArrayByte( long size, long byteAlignment )
127            : base( size, byteAlignment )
128        {
129            pAlignedArray = (byte*)AlignedMemory.ToPointer();
130        }
131
132        public IntPtr GetPtr( long index )
133        {
134            if( index>=Length || index<0 )
135                throw new IndexOutOfRangeException();
136
137            return new IntPtr( pAlignedArray+index );
138        }
139
140        public void Extract( long index, byte[] destinationArray, long destinationIndex, long length )
141        {
142            if( index+length>=Length || index+length<0 )
143                throw new IndexOutOfRangeException();
144
145            for( long i=0; i<length; i++ )
146                destinationArray[destinationIndex+i] = pAlignedArray[index+i];
147        }
148
149        public void Insert( long index, byte[] sourceArray, long sourceIndex, long length )
150        {
151            if( index+length>=Length || index+length<0 )
152                throw new IndexOutOfRangeException();
153
154            for( long i=0; i<length; i++ )
155                pAlignedArray[index+i] = sourceArray[sourceIndex+i];
156        }
157
158        public byte this[long index]
159        {
160            get
161            {
162                if( index<0 || index>=Length )
163                    throw new IndexOutOfRangeException();
164
165                return pAlignedArray[index];
166            }
167            set
168            {
169                if( index<0 || index>=Length )
170                    throw new IndexOutOfRangeException();
171
172                pAlignedArray[index] = value;
173            }
174        }
175
176        public static implicit operator IntPtr( AlignedArrayByte array )
177        {
178            return new IntPtr( array.pAlignedArray );
179        }
180    }
181
182    #endregion
183
184    #region AlignedArrayInt
185
186    /// <summary>
187    /// Aligned 1D array class for ints
188    /// </summary>
189    unsafe public class AlignedArrayInt : AlignedArray<int>
190    {
191        int* pAlignedArray;
192
193        public AlignedArrayInt(long size, long byteAlignment)
194            : base(size, byteAlignment)
195        {
196            pAlignedArray = (int*)AlignedMemory.ToPointer();
197        }
198
199        public IntPtr GetPtr(long index)
200        {
201            if (index >= Length || index < 0)
202                throw new IndexOutOfRangeException();
203
204            return new IntPtr(pAlignedArray + index);
205        }
206
207        public void Extract(long index, int[] destinationArray, long destinationIndex, long length)
208        {
209            if (index + length >= Length || index + length < 0)
210                throw new IndexOutOfRangeException();
211
212            for (long i = 0; i < length; i++)
213                destinationArray[destinationIndex + i] = pAlignedArray[index + i];
214        }
215
216        public void Insert(long index, int[] sourceArray, long sourceIndex, long length)
217        {
218            if (index + length >= Length || index + length < 0)
219                throw new IndexOutOfRangeException();
220
221            for (long i = 0; i < length; i++)
222                pAlignedArray[index + i] = sourceArray[sourceIndex + i];
223        }
224
225        public int this[long index]
226        {
227            get
228            {
229                if (index < 0 || index >= Length)
230                    throw new IndexOutOfRangeException();
231
232                return pAlignedArray[index];
233            }
234            set
235            {
236                if (index < 0 || index >= Length)
237                    throw new IndexOutOfRangeException();
238
239                pAlignedArray[index] = value;
240            }
241        }
242
243        public static implicit operator IntPtr(AlignedArrayInt array)
244        {
245            return new IntPtr(array.pAlignedArray);
246        }
247    }
248
249    #endregion
250
251    #region AlignedArrayLong
252
253    /// <summary>
254    /// Aligned 1D array class for longs
255    /// </summary>
256    unsafe public class AlignedArrayLong : AlignedArray<long>
257    {
258        long* pAlignedArray;
259
260        public AlignedArrayLong(long size, long byteAlignment)
261            : base(size, byteAlignment)
262        {
263            pAlignedArray = (long*)AlignedMemory.ToPointer();
264        }
265
266        public IntPtr GetPtr(long index)
267        {
268            if (index >= Length || index < 0)
269                throw new IndexOutOfRangeException();
270
271            return new IntPtr(pAlignedArray + index);
272        }
273
274        public void Extract(long index, long[] destinationArray, long destinationIndex, long length)
275        {
276            if (index + length >= Length || index + length < 0)
277                throw new IndexOutOfRangeException();
278
279            for (long i = 0; i < length; i++)
280                destinationArray[destinationIndex + i] = pAlignedArray[index + i];
281        }
282
283        public void Insert(long index, long[] sourceArray, long sourceIndex, long length)
284        {
285            if (index + length >= Length || index + length < 0)
286                throw new IndexOutOfRangeException();
287
288            for (long i = 0; i < length; i++)
289                pAlignedArray[index + i] = sourceArray[sourceIndex + i];
290        }
291
292        public long this[long index]
293        {
294            get
295            {
296                if (index < 0 || index >= Length)
297                    throw new IndexOutOfRangeException();
298
299                return pAlignedArray[index];
300            }
301            set
302            {
303                if (index < 0 || index >= Length)
304                    throw new IndexOutOfRangeException();
305
306                pAlignedArray[index] = value;
307            }
308        }
309
310        public static implicit operator IntPtr(AlignedArrayLong array)
311        {
312            return new IntPtr(array.pAlignedArray);
313        }
314    }
315
316    #endregion
317
318    #region AlignedArrayFloat
319
320    /// <summary>
321    /// Aligned 1D array class for floats
322    /// </summary>
323    unsafe public class AlignedArrayFloat : AlignedArray<float>
324    {
325        float* pAlignedArray;
326
327        public AlignedArrayFloat(long size, long byteAlignment)
328            : base(size, byteAlignment)
329        {
330            pAlignedArray = (float*)AlignedMemory.ToPointer();
331        }
332
333        public IntPtr GetPtr(long index)
334        {
335            if (index >= Length || index < 0)
336                throw new IndexOutOfRangeException();
337
338            return new IntPtr(pAlignedArray + index);
339        }
340
341        public void Extract(long index, float[] destinationArray, long destinationIndex, long length)
342        {
343            if (index + length >= Length || index + length < 0)
344                throw new IndexOutOfRangeException();
345
346            for (long i = 0; i < length; i++)
347                destinationArray[destinationIndex + i] = pAlignedArray[index + i];
348        }
349
350        public void Insert(long index, float[] sourceArray, long sourceIndex, long length)
351        {
352            if (index + length >= Length || index + length < 0)
353                throw new IndexOutOfRangeException();
354
355            for (long i = 0; i < length; i++)
356                pAlignedArray[index + i] = sourceArray[sourceIndex + i];
357        }
358
359        public float this[long index]
360        {
361            get
362            {
363                if (index < 0 || index >= Length)
364                    throw new IndexOutOfRangeException();
365
366                return pAlignedArray[index];
367            }
368            set
369            {
370                if (index < 0 || index >= Length)
371                    throw new IndexOutOfRangeException();
372
373                pAlignedArray[index] = value;
374            }
375        }
376
377        public static implicit operator IntPtr(AlignedArrayFloat array)
378        {
379            return new IntPtr(array.pAlignedArray);
380        }
381    }
382
383    #endregion
384
385}
Note: See TracBrowser for help on using the repository browser.