All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
IntrinsicTrait.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_INTRINSICS_INTRINSICTRAIT_H_
36 #define _BLAZE_MATH_INTRINSICS_INTRINSICTRAIT_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
46 #include <blaze/util/Complex.h>
48 #include <blaze/util/TypeTraits.h>
49 
50 
51 namespace blaze {
52 
53 //=================================================================================================
54 //
55 // CLASS INTRINSICTRAITHELPER
56 //
57 //=================================================================================================
58 
59 //*************************************************************************************************
67 template< size_t N >
68 struct IntrinsicTraitHelper;
70 //*************************************************************************************************
71 
72 
73 //*************************************************************************************************
78 #if BLAZE_AVX2_MODE
79 template<>
80 struct IntrinsicTraitHelper<1UL>
81 {
82  typedef sse_int8_t Type;
83  enum { size = 32,
84  addition = 1,
85  subtraction = 1,
86  multiplication = 0,
87  division = 0,
88  absoluteValue = 1 };
89 };
90 #else
91 template<>
92 struct IntrinsicTraitHelper<1UL>
93 {
94  typedef sse_int8_t Type;
95  enum { size = ( BLAZE_SSE2_MODE )?( 16 ):( 1 ),
96  addition = BLAZE_SSE2_MODE,
97  subtraction = BLAZE_SSE2_MODE,
98  multiplication = 0,
99  division = 0,
100  absoluteValue = BLAZE_SSSE3_MODE };
101 };
102 #endif
103 
104 //*************************************************************************************************
105 
106 
107 //*************************************************************************************************
112 #if BLAZE_AVX2_MODE
113 template<>
114 struct IntrinsicTraitHelper<2UL>
115 {
116  typedef sse_int16_t Type;
117  enum { size = 16,
118  addition = 1,
119  subtraction = 1,
120  multiplication = 1,
121  division = 0,
122  absoluteValue = 1 };
123 };
124 #else
125 template<>
126 struct IntrinsicTraitHelper<2UL>
127 {
128  typedef sse_int16_t Type;
129  enum { size = ( BLAZE_SSE2_MODE )?( 8 ):( 1 ),
130  addition = BLAZE_SSE2_MODE,
131  subtraction = BLAZE_SSE2_MODE,
132  multiplication = BLAZE_SSE2_MODE,
133  division = 0,
134  absoluteValue = BLAZE_SSSE3_MODE };
135 };
136 #endif
137 
138 //*************************************************************************************************
139 
140 
141 //*************************************************************************************************
146 #if BLAZE_MIC_MODE
147 template<>
148 struct IntrinsicTraitHelper<4UL>
149 {
150  typedef sse_int32_t Type;
151  enum { size = 16,
152  addition = 1,
153  subtraction = 1,
154  multiplication = 1,
155  division = 1,
156  absoluteValue = 0 };
157 };
158 #elif BLAZE_AVX2_MODE
159 template<>
160 struct IntrinsicTraitHelper<4UL>
161 {
162  typedef sse_int32_t Type;
163  enum { size = 8,
164  addition = 1,
165  subtraction = 1,
166  multiplication = 1,
167  division = 0,
168  absoluteValue = 1 };
169 };
170 #else
171 template<>
172 struct IntrinsicTraitHelper<4UL>
173 {
174  typedef sse_int32_t Type;
175  enum { size = ( BLAZE_SSE2_MODE )?( 4 ):( 1 ),
176  addition = BLAZE_SSE2_MODE,
177  subtraction = BLAZE_SSE2_MODE,
178  multiplication = BLAZE_SSE4_MODE,
179  division = 0,
180  absoluteValue = BLAZE_SSSE3_MODE };
181 };
182 #endif
183 
184 //*************************************************************************************************
185 
186 
187 //*************************************************************************************************
192 #if BLAZE_MIC_MODE
193 template<>
194 struct IntrinsicTraitHelper<8UL>
195 {
196  typedef sse_int64_t Type;
197  enum { size = 8,
198  addition = 1,
199  subtraction = 0,
200  multiplication = 0,
201  division = 1,
202  absoluteValue = 0 };
203 };
204 #elif BLAZE_AVX2_MODE
205 template<>
206 struct IntrinsicTraitHelper<8UL>
207 {
208  typedef sse_int64_t Type;
209  enum { size = 4,
210  addition = 1,
211  subtraction = 1,
212  multiplication = 0,
213  division = 0,
214  absoluteValue = 0 };
215 };
216 #else
217 template<>
218 struct IntrinsicTraitHelper<8UL>
219 {
220  typedef sse_int64_t Type;
221  enum { size = ( BLAZE_SSE2_MODE )?( 2 ):( 1 ),
222  addition = BLAZE_SSE2_MODE,
223  subtraction = BLAZE_SSE2_MODE,
224  multiplication = 0,
225  division = 0,
226  absoluteValue = 0 };
227 };
228 #endif
229 
230 //*************************************************************************************************
231 
232 
233 
234 
235 //=================================================================================================
236 //
237 // CLASS INTRINSICTRAITBASE
238 //
239 //=================================================================================================
240 
241 //*************************************************************************************************
246 template< typename T >
247 struct IntrinsicTraitBase
248 {
249  typedef T Type;
250  enum { size = 1,
251  alignment = AlignmentTrait<T>::value,
252  addition = 0,
253  subtraction = 0,
254  multiplication = 0,
255  division = 0,
256  absoluteValue = 0 };
257 };
259 //*************************************************************************************************
260 
261 
262 //*************************************************************************************************
267 template<>
268 struct IntrinsicTraitBase<short>
269 {
270  private:
271  typedef IntrinsicTraitHelper<sizeof(short)> Helper;
272 
273  public:
274  typedef Helper::Type Type;
275  enum { size = Helper::size,
276  alignment = AlignmentTrait<short>::value,
277  addition = Helper::addition,
278  subtraction = Helper::subtraction,
279  multiplication = Helper::multiplication,
280  division = Helper::division,
281  absoluteValue = Helper::absoluteValue };
282 };
284 //*************************************************************************************************
285 
286 
287 //*************************************************************************************************
292 template<>
293 struct IntrinsicTraitBase<unsigned short>
294 {
295  private:
296  typedef IntrinsicTraitHelper<sizeof(unsigned short)> Helper;
297 
298  public:
299  typedef Helper::Type Type;
300  enum { size = Helper::size,
301  alignment = AlignmentTrait<unsigned short>::value,
302  addition = Helper::addition,
303  subtraction = Helper::subtraction,
304  multiplication = Helper::multiplication,
305  division = Helper::division,
306  absoluteValue = Helper::absoluteValue };
307 };
309 //*************************************************************************************************
310 
311 
312 //*************************************************************************************************
317 template<>
318 struct IntrinsicTraitBase<int>
319 {
320  private:
321  typedef IntrinsicTraitHelper<sizeof(int)> Helper;
322 
323  public:
324  typedef Helper::Type Type;
325  enum { size = Helper::size,
326  alignment = AlignmentTrait<int>::value,
327  addition = Helper::addition,
328  subtraction = Helper::subtraction,
329  multiplication = Helper::multiplication,
330  division = Helper::division,
331  absoluteValue = Helper::absoluteValue };
332 };
334 //*************************************************************************************************
335 
336 
337 //*************************************************************************************************
342 template<>
343 struct IntrinsicTraitBase<unsigned int>
344 {
345  private:
346  typedef IntrinsicTraitHelper<sizeof(unsigned int)> Helper;
347 
348  public:
349  typedef Helper::Type Type;
350  enum { size = Helper::size,
351  alignment = AlignmentTrait<unsigned int>::value,
352  addition = Helper::addition,
353  subtraction = Helper::subtraction,
354  multiplication = Helper::multiplication,
355  division = Helper::division,
356  absoluteValue = Helper::absoluteValue };
357 };
359 //*************************************************************************************************
360 
361 
362 //*************************************************************************************************
367 template<>
368 struct IntrinsicTraitBase<long>
369 {
370  private:
371  typedef IntrinsicTraitHelper<sizeof(long)> Helper;
372 
373  public:
374  typedef Helper::Type Type;
375  enum { size = Helper::size,
376  alignment = AlignmentTrait<long>::value,
377  addition = Helper::addition,
378  subtraction = Helper::subtraction,
379  multiplication = Helper::multiplication,
380  division = Helper::division,
381  absoluteValue = Helper::absoluteValue };
382 };
384 //*************************************************************************************************
385 
386 
387 //*************************************************************************************************
392 template<>
393 struct IntrinsicTraitBase<unsigned long>
394 {
395  private:
396  typedef IntrinsicTraitHelper<sizeof(unsigned long)> Helper;
397 
398  public:
399  typedef Helper::Type Type;
400  enum { size = Helper::size,
401  alignment = AlignmentTrait<unsigned long>::value,
402  addition = Helper::addition,
403  subtraction = Helper::subtraction,
404  multiplication = Helper::multiplication,
405  division = Helper::division,
406  absoluteValue = Helper::absoluteValue };
407 };
409 //*************************************************************************************************
410 
411 
412 //*************************************************************************************************
417 #if BLAZE_MIC_MODE
418 struct IntrinsicTraitBase<float>
419 {
420  typedef sse_float_t Type;
421  enum { size = ( 64UL / sizeof(float) ),
422  alignment = AlignmentTrait<float>::value,
423  addition = 1,
424  subtraction = 1,
425  multiplication = 1,
426  division = 1,
427  absoluteValue = 0 };
428 };
429 #elif BLAZE_AVX_MODE
430 template<>
431 struct IntrinsicTraitBase<float>
432 {
433  typedef sse_float_t Type;
434  enum { size = ( 32UL / sizeof(float) ),
435  alignment = AlignmentTrait<float>::value,
436  addition = 1,
437  subtraction = 1,
438  multiplication = 1,
439  division = 1,
440  absoluteValue = 0 };
441 };
442 #else
443 template<>
444 struct IntrinsicTraitBase<float>
445 {
446  typedef sse_float_t Type;
447  enum { size = ( BLAZE_SSE_MODE )?( 16UL / sizeof(float) ):( 1 ),
448  alignment = AlignmentTrait<float>::value,
449  addition = BLAZE_SSE_MODE,
450  subtraction = BLAZE_SSE_MODE,
451  multiplication = BLAZE_SSE_MODE,
452  division = BLAZE_SSE_MODE,
453  absoluteValue = 0 };
454 };
455 #endif
456 
457 //*************************************************************************************************
458 
459 
460 //*************************************************************************************************
465 #if BLAZE_MIC_MODE
466 template<>
467 struct IntrinsicTraitBase<double>
468 {
469  typedef sse_double_t Type;
470  enum { size = ( 64UL / sizeof(double) ),
471  alignment = AlignmentTrait<double>::value,
472  addition = 1,
473  subtraction = 1,
474  multiplication = 1,
475  division = 1,
476  absoluteValue = 0 };
477 };
478 #elif BLAZE_AVX_MODE
479 template<>
480 struct IntrinsicTraitBase<double>
481 {
482  typedef sse_double_t Type;
483  enum { size = ( 32UL / sizeof(double) ),
484  alignment = AlignmentTrait<double>::value,
485  addition = 1,
486  subtraction = 1,
487  multiplication = 1,
488  division = 1,
489  absoluteValue = 0 };
490 };
491 #else
492 template<>
493 struct IntrinsicTraitBase<double>
494 {
495  typedef sse_double_t Type;
496  enum { size = ( BLAZE_SSE_MODE )?( 16UL / sizeof(double) ):( 1 ),
497  alignment = AlignmentTrait<double>::value,
498  addition = BLAZE_SSE2_MODE,
499  subtraction = BLAZE_SSE2_MODE,
500  multiplication = BLAZE_SSE2_MODE,
501  division = BLAZE_SSE2_MODE,
502  absoluteValue = 0 };
503 };
504 #endif
505 
506 //*************************************************************************************************
507 
508 
509 //*************************************************************************************************
514 #if BLAZE_MIC_MODE
515 template<>
516 struct IntrinsicTraitBase< complex<float> >
517 {
518  typedef sse_cfloat_t Type;
519  enum { size = ( 64UL / sizeof(complex<float>) ),
520  alignment = AlignmentTrait< complex<float> >::value,
521  addition = 1,
522  subtraction = 1,
523  multiplication = 0,
524  division = 0,
525  absoluteValue = 0 };
526 
527  BLAZE_STATIC_ASSERT( sizeof( complex<float> ) == 2UL*sizeof( float ) );
528 };
529 #elif BLAZE_AVX_MODE
530 template<>
531 struct IntrinsicTraitBase< complex<float> >
532 {
533  typedef sse_cfloat_t Type;
534  enum { size = ( 32UL / sizeof(complex<float>) ),
535  alignment = AlignmentTrait< complex<float> >::value,
536  addition = 1,
537  subtraction = 1,
538  multiplication = 1,
539  division = 0,
540  absoluteValue = 0 };
541 
542  BLAZE_STATIC_ASSERT( sizeof( complex<float> ) == 2UL*sizeof( float ) );
543 };
544 #else
545 template<>
546 struct IntrinsicTraitBase< complex<float> >
547 {
548  typedef sse_cfloat_t Type;
549  enum { size = ( BLAZE_SSE_MODE )?( 16UL / sizeof(complex<float>) ):( 1 ),
550  alignment = AlignmentTrait< complex<float> >::value,
551  addition = BLAZE_SSE_MODE,
552  subtraction = BLAZE_SSE_MODE,
553  multiplication = BLAZE_SSE3_MODE,
554  division = 0,
555  absoluteValue = 0 };
556 
557  BLAZE_STATIC_ASSERT( sizeof( complex<float> ) == 2UL*sizeof( float ) );
558 };
559 #endif
560 
561 //*************************************************************************************************
562 
563 
564 //*************************************************************************************************
569 #if BLAZE_MIC_MODE
570 template<>
571 struct IntrinsicTraitBase< complex<double> >
572 {
573  typedef sse_cdouble_t Type;
574  enum { size = ( 64UL / sizeof(complex<double>) ),
575  alignment = AlignmentTrait< complex<double> >::value,
576  addition = 1,
577  subtraction = 1,
578  multiplication = 0,
579  division = 0,
580  absoluteValue = 0 };
581 
582  BLAZE_STATIC_ASSERT( sizeof( complex<double> ) == 2UL*sizeof( double ) );
583 };
584 #elif BLAZE_AVX_MODE
585 template<>
586 struct IntrinsicTraitBase< complex<double> >
587 {
588  typedef sse_cdouble_t Type;
589  enum { size = ( 32UL / sizeof(complex<double>) ),
590  alignment = AlignmentTrait< complex<double> >::value,
591  addition = 1,
592  subtraction = 1,
593  multiplication = 1,
594  division = 0,
595  absoluteValue = 0 };
596 
597  BLAZE_STATIC_ASSERT( sizeof( complex<double> ) == 2UL*sizeof( double ) );
598 };
599 #else
600 template<>
601 struct IntrinsicTraitBase< complex<double> >
602 {
603  typedef sse_cdouble_t Type;
604  enum { size = ( BLAZE_SSE_MODE )?( 16UL / sizeof(complex<double>) ):( 1 ),
605  alignment = AlignmentTrait< complex<double> >::value,
606  addition = BLAZE_SSE2_MODE,
607  subtraction = BLAZE_SSE2_MODE,
608  multiplication = BLAZE_SSE3_MODE,
609  division = 0,
610  absoluteValue = 0 };
611 
612  BLAZE_STATIC_ASSERT( sizeof( complex<double> ) == 2UL*sizeof( double ) );
613 };
614 #endif
615 
616 //*************************************************************************************************
617 
618 
619 
620 
621 //=================================================================================================
622 //
623 // CLASS INTRINSICTRAIT
624 //
625 //=================================================================================================
626 
627 //*************************************************************************************************
647 template< typename T >
648 class IntrinsicTrait : public IntrinsicTraitBase< typename RemoveCV<T>::Type >
649 {};
650 //*************************************************************************************************
651 
652 } // namespace blaze
653 
654 #endif
#define BLAZE_SSE3_MODE
Compilation switch for the SSE3 mode.This compilation switch enables/disables the SSE3 mode...
Definition: Vectorization.h:100
#define BLAZE_SSSE3_MODE
Compilation switch for the SSSE3 mode.This compilation switch enables/disables the SSSE3 mode...
Definition: Vectorization.h:117
Compile time assertion.
#define BLAZE_SSE_MODE
Compilation switch for the SSE mode.This compilation switch enables/disables the SSE mode...
Definition: Vectorization.h:66
Header file for the basic intrinsic types.
Header file for all type traits.
Intrinsic characteristics of data types.The IntrinsicTrait class template provides the intrinsic char...
Definition: IntrinsicTrait.h:648
#define BLAZE_SSE4_MODE
Compilation switch for the SSE4 mode.This compilation switch enables/disables the SSE4 mode...
Definition: Vectorization.h:134
Header file for the alignment trait.
System settings for the SSE mode.
Header file for the complex data type.
#define BLAZE_SSE2_MODE
Compilation switch for the SSE2 mode.This compilation switch enables/disables the SSE2 mode...
Definition: Vectorization.h:83
#define BLAZE_STATIC_ASSERT(expr)
Compile time assertion macro.In case of an invalid compile time expression, a compilation error is cr...
Definition: StaticAssert.h:143