IPSDK  4_1_0_2
IPSDK : Image Processing Software Development Kit
MaskCastReg.h
Go to the documentation of this file.
1 // MaskCastReg.h:
3 // ------------
4 //
14 
15 #ifndef __IPSDKUTIL_INSTRUCTIONSET_DETAIL_AVX2_MASKCASTREG_H__
16 #define __IPSDKUTIL_INSTRUCTIONSET_DETAIL_AVX2_MASKCASTREG_H__
17 
18 #include <IPSDKUtil/IPSDKUtilExports.h>
19 #include <IPSDKUtil/InstructionSet/detail/CastReg.h>
20 #include <IPSDKUtil/InstructionSet/detail/AssignReg.h>
21 #include <IPSDKUtil/InstructionSet/Comparison/detail/IsNotEqualReg.h>
22 #include <IPSDKUtil/InstructionSet/RegMaskType.h>
23 #include <IPSDKUtil/Tools/ForceInline.h>
24 
25 #include <boost/mpl/and.hpp>
26 #include <boost/mpl/equal_to.hpp>
27 #include <boost/mpl/int.hpp>
28 #include <boost/mpl/not.hpp>
29 #include <boost/mpl/or.hpp>
30 #include <boost/mpl/sizeof.hpp>
31 #include <boost/type_traits/is_signed.hpp>
32 
33 namespace ipsdk {
34 namespace simd {
35 namespace detail {
36 
39 
42 template <typename TIn, typename TOut>
43 struct MaskCastReg<
44  eInstructionSet::eIS_Avx2,
45  TIn,
46  TOut,
47  typename boost::enable_if<
48  typename boost::mpl::or_<
49  typename boost::is_same<TIn, TOut>::type,
50  typename boost::mpl::and_<
51  typename boost::is_integral<TIn>::type,
52  typename boost::mpl::and_<
53  typename boost::is_integral<TOut>::type,
54  typename boost::mpl::equal_to<
55  boost::mpl::sizeof_<TIn>,
56  boost::mpl::sizeof_<TOut>
57  >::type
58  >::type
59  >::type
60  >::type
61  >::type
62 >
63 {
64  static IPSDK_FORCEINLINE
65  void act(const typename RegMaskType<eInstructionSet::eIS_Avx2, TIn>::Type& in,
66  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out)
67  {
68  out = in;
69  }
70 };
71 
74 template <typename TIn, typename TOut>
75 struct MaskCastReg<
76  eInstructionSet::eIS_Avx2,
77  TIn,
78  TOut,
79  typename boost::enable_if<
80  typename boost::mpl::and_<
81  typename boost::mpl::equal_to<
82  boost::mpl::sizeof_<TIn>,
83  boost::mpl::sizeof_<TOut>
84  >::type,
85  typename boost::mpl::or_<
86  typename boost::mpl::and_<
87  typename boost::mpl::not_<typename boost::is_integral<TIn>::type>::type,
88  typename boost::is_integral<TOut>::type
89  >::type,
90  typename boost::mpl::and_<
91  typename boost::mpl::not_<typename boost::is_integral<TOut>::type>::type,
92  typename boost::is_integral<TIn>::type
93  >::type
94  >::type
95  >::type
96  >::type
97 >
98 {
99  static IPSDK_FORCEINLINE
100  void act(
101  const typename RegMaskType<eInstructionSet::eIS_Avx2, TIn>::Type& in,
102  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out)
103  {
104  BitwiseCastReg<eInstructionSet::eIS_Avx2, TIn, TOut>::act(in, out);
105  }
106 };
107 
110 template <typename TIn, typename TOut>
111 struct MaskCastReg<
112  eInstructionSet::eIS_Avx2,
113  TIn,
114  TOut,
115  typename boost::enable_if<
116  typename boost::mpl::and_<
117  typename boost::mpl::equal_to<
118  boost::mpl::sizeof_<TIn>,
119  boost::mpl::int_<1>
120  >::type,
121  typename boost::mpl::equal_to<
122  boost::mpl::sizeof_<TOut>,
123  boost::mpl::int_<2>
124  >::type
125  >::type
126  >::type
127 >
128 {
129  static IPSDK_FORCEINLINE
130  void act(
131  const typename RegMaskType<eInstructionSet::eIS_Avx2, TIn>::Type& in,
132  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out0,
133  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out1)
134  {
135  typename RegType<eInstructionSet::eIS_Avx2, TOut>::Type zero;
136  AssignReg<eInstructionSet::eIS_Avx2, TOut>::act(zero, 0);
137  CastReg<eInstructionSet::eIS_Avx2, TIn, TOut>::act(in, out0, out1);
138  IsNotEqualReg<eInstructionSet::eIS_Avx2, TOut>::act(out0, zero, out0);
139  IsNotEqualReg<eInstructionSet::eIS_Avx2, TOut>::act(out1, zero, out1);
140  }
141 };
142 
145 template <typename TIn, typename TOut>
146 struct MaskCastReg<
147  eInstructionSet::eIS_Avx2,
148  TIn,
149  TOut,
150  typename boost::enable_if<
151  typename boost::mpl::and_<
152  typename boost::mpl::equal_to<
153  boost::mpl::sizeof_<TIn>,
154  boost::mpl::int_<1>
155  >::type,
156  typename boost::mpl::equal_to<
157  boost::mpl::sizeof_<TOut>,
158  boost::mpl::int_<4>
159  >::type
160  >::type
161  >::type
162 >
163 {
164  static IPSDK_FORCEINLINE
165  void act(
166  const typename RegMaskType<eInstructionSet::eIS_Avx2, TIn>::Type& in,
167  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out0,
168  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out1,
169  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out2,
170  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out3)
171  {
172  typedef typename UpperType<TIn>::Type T16;
173  typename RegMaskType<eInstructionSet::eIS_Avx2, T16>::Type in0, in1;
174  CastReg<eInstructionSet::eIS_Avx2, TIn, T16>::act(in, in0, in1);
175  MaskCastReg<eInstructionSet::eIS_Avx2, T16, TOut>::act(in0, out0, out1);
176  MaskCastReg<eInstructionSet::eIS_Avx2, T16, TOut>::act(in1, out2, out3);
177  }
178 };
179 
182 template <typename TIn, typename TOut>
183 struct MaskCastReg<
184  eInstructionSet::eIS_Avx2,
185  TIn,
186  TOut,
187  typename boost::enable_if<
188  typename boost::mpl::and_<
189  typename boost::mpl::equal_to<
190  boost::mpl::sizeof_<TIn>,
191  boost::mpl::int_<1>
192  >::type,
193  typename boost::mpl::equal_to<
194  boost::mpl::sizeof_<TOut>,
195  boost::mpl::int_<8>
196  >::type
197  >::type
198  >::type
199 >
200 {
201  static IPSDK_FORCEINLINE
202  void act(
203  const typename RegMaskType<eInstructionSet::eIS_Avx2, TIn>::Type& in,
204  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out0,
205  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out1,
206  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out2,
207  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out3,
208  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out4,
209  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out5,
210  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out6,
211  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out7)
212  {
213  typedef typename UpperType<TIn>::Type T16;
214  typename RegMaskType<eInstructionSet::eIS_Avx2, T16>::Type in16_0, in16_1;
215  CastReg<eInstructionSet::eIS_Avx2, TIn, T16>::act(in, in16_0, in16_1);
216 
217  typedef typename UpperType<T16>::Type T32;
218  typename RegMaskType<eInstructionSet::eIS_Avx2, T32>::Type in32_0, in32_1, in32_2, in32_3;
219  CastReg<eInstructionSet::eIS_Avx2, T16, T32>::act(in16_0, in32_0, in32_1);
220  CastReg<eInstructionSet::eIS_Avx2, T16, T32>::act(in16_1, in32_2, in32_3);
221 
222  MaskCastReg<eInstructionSet::eIS_Avx2, T32, TOut>::act(in32_0, out0, out1);
223  MaskCastReg<eInstructionSet::eIS_Avx2, T32, TOut>::act(in32_1, out2, out3);
224  MaskCastReg<eInstructionSet::eIS_Avx2, T32, TOut>::act(in32_2, out4, out5);
225  MaskCastReg<eInstructionSet::eIS_Avx2, T32, TOut>::act(in32_3, out6, out7);
226  }
227 };
228 
231 template <typename TIn, typename TOut>
232 struct MaskCastReg<
233  eInstructionSet::eIS_Avx2,
234  TIn,
235  TOut,
236  typename boost::enable_if<
237  typename boost::mpl::and_<
238  typename boost::mpl::equal_to<
239  boost::mpl::sizeof_<TIn>,
240  boost::mpl::int_<2>
241  >::type,
242  typename boost::mpl::equal_to<
243  boost::mpl::sizeof_<TOut>,
244  boost::mpl::int_<4>
245  >::type
246  >::type
247  >::type
248 >
249 {
250  static IPSDK_FORCEINLINE
251  void act(
252  const typename RegMaskType<eInstructionSet::eIS_Avx2, TIn>::Type& in,
253  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out0,
254  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out1)
255  {
256  typename RegType<eInstructionSet::eIS_Avx2, TOut>::Type zero;
257  AssignReg<eInstructionSet::eIS_Avx2, TOut>::act(zero, 0);
258  CastReg<eInstructionSet::eIS_Avx2, TIn, TOut>::act(in, out0, out1);
259  IsNotEqualReg<eInstructionSet::eIS_Avx2, TOut>::act(out0, zero, out0);
260  IsNotEqualReg<eInstructionSet::eIS_Avx2, TOut>::act(out1, zero, out1);
261  }
262 };
263 
266 template <typename TIn, typename TOut>
267 struct MaskCastReg<
268  eInstructionSet::eIS_Avx2,
269  TIn,
270  TOut,
271  typename boost::enable_if<
272  typename boost::mpl::and_<
273  typename boost::mpl::equal_to<
274  boost::mpl::sizeof_<TIn>,
275  boost::mpl::int_<2>
276  >::type,
277  typename boost::mpl::equal_to<
278  boost::mpl::sizeof_<TOut>,
279  boost::mpl::int_<8>
280  >::type
281  >::type
282  >::type
283 >
284 {
285  static IPSDK_FORCEINLINE
286  void act(
287  const typename RegMaskType<eInstructionSet::eIS_Avx2, TIn>::Type& in,
288  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out0,
289  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out1,
290  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out2,
291  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out3)
292  {
293  typedef typename UpperType<TIn>::Type T32;
294  typename RegMaskType<eInstructionSet::eIS_Avx2, T32>::Type in0, in1;
295  CastReg<eInstructionSet::eIS_Avx2, TIn, T32>::act(in, in0, in1);
296  MaskCastReg<eInstructionSet::eIS_Avx2, T32, TOut>::act(in0, out0, out1);
297  MaskCastReg<eInstructionSet::eIS_Avx2, T32, TOut>::act(in1, out2, out3);
298  }
299 };
300 
303 template <typename TIn, typename TOut>
304 struct MaskCastReg<
305  eInstructionSet::eIS_Avx2,
306  TIn,
307  TOut,
308  typename boost::enable_if<
309  typename boost::mpl::and_<
310  typename boost::mpl::and_<
311  typename boost::mpl::equal_to<
312  boost::mpl::sizeof_<TIn>,
313  boost::mpl::int_<4>
314  >::type,
315  typename boost::is_integral<TIn>::type
316  >::type,
317  typename boost::mpl::equal_to<
318  boost::mpl::sizeof_<TOut>,
319  boost::mpl::int_<8>
320  >::type
321  >::type
322  >::type
323 >
324 {
325  static IPSDK_FORCEINLINE
326  void act(
327  const typename RegMaskType<eInstructionSet::eIS_Avx2, TIn>::Type& in,
328  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out0,
329  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out1)
330  {
331  typename RegType<eInstructionSet::eIS_Avx2, TOut>::Type zero;
332  AssignReg<eInstructionSet::eIS_Avx2, TOut>::act(zero, 0);
333  CastReg<eInstructionSet::eIS_Avx2, TIn, TOut>::act(in, out0, out1);
334  IsNotEqualReg<eInstructionSet::eIS_Avx2, TOut>::act(out0, zero, out0);
335  IsNotEqualReg<eInstructionSet::eIS_Avx2, TOut>::act(out1, zero, out1);
336  }
337 };
338 
341 template <typename TOut>
342 struct MaskCastReg<
343  eInstructionSet::eIS_Avx2,
344  ipReal32,
345  TOut,
346  typename boost::enable_if<
347  typename boost::mpl::equal_to<
348  boost::mpl::sizeof_<TOut>,
349  boost::mpl::int_<8>
350  >::type
351  >::type
352 >
353 {
354  static IPSDK_FORCEINLINE
355  void act(
356  const RegMaskType<eInstructionSet::eIS_Avx2, ipReal32>::Type& in,
357  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out0,
358  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out1)
359  {
360  RegMaskType<eInstructionSet::eIS_Avx2, ipUInt32>::Type inUI;
361  MaskCastReg<eInstructionSet::eIS_Avx2, ipReal32, ipUInt32>::act(in, inUI);
362  MaskCastReg<eInstructionSet::eIS_Avx2, ipUInt32, TOut>::act(inUI, out0, out1);
363  }
364 };
365 
368 template <typename TIn, typename TOut>
369 struct MaskCastReg<
370  eInstructionSet::eIS_Avx2,
371  TIn,
372  TOut,
373  typename boost::enable_if<
374  typename boost::mpl::and_<
375  typename boost::mpl::equal_to<
376  boost::mpl::sizeof_<TIn>,
377  boost::mpl::int_<2>
378  >::type,
379  typename boost::mpl::equal_to<
380  boost::mpl::sizeof_<TOut>,
381  boost::mpl::int_<1>
382  >::type
383  >::type
384  >::type
385 >
386 {
387  static IPSDK_FORCEINLINE
388  void act(
389  const typename RegMaskType<eInstructionSet::eIS_Avx2, TIn>::Type& in0,
390  const typename RegMaskType<eInstructionSet::eIS_Avx2, TIn>::Type& in1,
391  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out)
392  {
393  typename RegType<eInstructionSet::eIS_Avx2, TOut>::Type zero;
394  AssignReg<eInstructionSet::eIS_Avx2, TOut>::act(zero, 0);
395  CastReg<eInstructionSet::eIS_Avx2, ipInt16, ipInt8>::act(in0, in1, out);
396  IsNotEqualReg<eInstructionSet::eIS_Avx2, TOut>::act(out, zero, out);
397  }
398 };
399 
402 template <typename TIn, typename TOut>
403 struct MaskCastReg<
404  eInstructionSet::eIS_Avx2,
405  TIn,
406  TOut,
407  typename boost::enable_if<
408  typename boost::mpl::and_<
409  typename boost::mpl::and_<
410  typename boost::mpl::equal_to<
411  boost::mpl::sizeof_<TIn>,
412  boost::mpl::int_<4>
413  >::type,
414  typename boost::is_integral<TIn>::type
415  >::type,
416  typename boost::mpl::equal_to<
417  boost::mpl::sizeof_<TOut>,
418  boost::mpl::int_<2>
419  >::type
420  >::type
421  >::type
422 >
423 {
424  static IPSDK_FORCEINLINE
425  void act(
426  const typename RegMaskType<eInstructionSet::eIS_Avx2, TIn>::Type& in0,
427  const typename RegMaskType<eInstructionSet::eIS_Avx2, TIn>::Type& in1,
428  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out)
429  {
430  typename RegType<eInstructionSet::eIS_Avx2, TOut>::Type zero;
431  AssignReg<eInstructionSet::eIS_Avx2, TOut>::act(zero, 0);
432  CastReg<eInstructionSet::eIS_Avx2, ipInt32, ipInt16>::act(in0, in1, out);
433  IsNotEqualReg<eInstructionSet::eIS_Avx2, TOut>::act(out, zero, out);
434  }
435 };
436 
439 template <typename TOut>
440 struct MaskCastReg<
441  eInstructionSet::eIS_Avx2,
442  ipReal32,
443  TOut,
444  typename boost::enable_if<
445  typename boost::mpl::equal_to<
446  boost::mpl::sizeof_<TOut>,
447  boost::mpl::int_<2>
448  >::type
449  >::type
450 >
451 {
452  static IPSDK_FORCEINLINE
453  void act(
454  const RegMaskType<eInstructionSet::eIS_Avx2, ipReal32>::Type& in0,
455  const typename RegMaskType<eInstructionSet::eIS_Avx2, ipReal32>::Type& in1,
456  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out)
457  {
458  RegMaskType<eInstructionSet::eIS_Avx2, ipUInt32>::Type inUI0, inUI1;
459  MaskCastReg<eInstructionSet::eIS_Avx2, ipReal32, ipUInt32>::act(in0, inUI0);
460  MaskCastReg<eInstructionSet::eIS_Avx2, ipReal32, ipUInt32>::act(in1, inUI1);
461  MaskCastReg<eInstructionSet::eIS_Avx2, ipUInt32, TOut>::act(inUI0, inUI1, out);
462  }
463 };
464 
467 template <typename TIn, typename TOut>
468 struct MaskCastReg<
469  eInstructionSet::eIS_Avx2,
470  TIn,
471  TOut,
472  typename boost::enable_if<
473  typename boost::mpl::and_<
474  typename boost::mpl::and_<
475  typename boost::mpl::equal_to<
476  boost::mpl::sizeof_<TIn>,
477  boost::mpl::int_<4>
478  >::type,
479  typename boost::is_integral<TIn>::type
480  >::type,
481  typename boost::mpl::equal_to<
482  boost::mpl::sizeof_<TOut>,
483  boost::mpl::int_<1>
484  >::type
485  >::type
486  >::type
487 >
488 {
489  static IPSDK_FORCEINLINE
490  void act(
491  const typename RegMaskType<eInstructionSet::eIS_Avx2, TIn>::Type& in0,
492  const typename RegMaskType<eInstructionSet::eIS_Avx2, TIn>::Type& in1,
493  const typename RegMaskType<eInstructionSet::eIS_Avx2, TIn>::Type& in2,
494  const typename RegMaskType<eInstructionSet::eIS_Avx2, TIn>::Type& in3,
495  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out)
496  {
497  RegMaskType<eInstructionSet::eIS_Avx2, ipInt16>::Type out0, out1;
498  CastReg<eInstructionSet::eIS_Avx2, ipInt32, ipInt16>::act(in0, in1, out0);
499  CastReg<eInstructionSet::eIS_Avx2, ipInt32, ipInt16>::act(in2, in3, out1);
500  MaskCastReg<eInstructionSet::eIS_Avx2, ipInt16, TOut>::act(out0, out1, out);
501  }
502 };
503 
506 template <typename TOut>
507 struct MaskCastReg<
508  eInstructionSet::eIS_Avx2,
509  ipReal32,
510  TOut,
511  typename boost::enable_if<
512  typename boost::mpl::equal_to<
513  boost::mpl::sizeof_<TOut>,
514  boost::mpl::int_<1>
515  >::type
516  >::type
517 >
518 {
519  static IPSDK_FORCEINLINE
520  void act(
521  const RegMaskType<eInstructionSet::eIS_Avx2, ipReal32>::Type& in0,
522  const RegMaskType<eInstructionSet::eIS_Avx2, ipReal32>::Type& in1,
523  const RegMaskType<eInstructionSet::eIS_Avx2, ipReal32>::Type& in2,
524  const RegMaskType<eInstructionSet::eIS_Avx2, ipReal32>::Type& in3,
525  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out)
526  {
527  RegMaskType<eInstructionSet::eIS_Avx2, ipUInt32>::Type inUI0, inUI1, inUI2, inUI3;
528  MaskCastReg<eInstructionSet::eIS_Avx2, ipReal32, ipUInt32>::act(in0, inUI0);
529  MaskCastReg<eInstructionSet::eIS_Avx2, ipReal32, ipUInt32>::act(in1, inUI1);
530  MaskCastReg<eInstructionSet::eIS_Avx2, ipReal32, ipUInt32>::act(in2, inUI2);
531  MaskCastReg<eInstructionSet::eIS_Avx2, ipReal32, ipUInt32>::act(in3, inUI3);
532  MaskCastReg<eInstructionSet::eIS_Avx2, ipUInt32, TOut>::act(inUI0, inUI1, inUI2, inUI3, out);
533  }
534 };
535 /*
538 template <typename TIn, typename TOut>
539 struct MaskCastReg<
540  eInstructionSet::eIS_Avx2,
541  TIn,
542  TOut,
543  typename boost::enable_if<
544  typename boost::mpl::and_<
545  typename boost::mpl::and_<
546  typename boost::mpl::equal_to<
547  boost::mpl::sizeof_<TIn>,
548  boost::mpl::int_<8>
549  >::type,
550  typename boost::is_integral<TIn>::type
551  >::type,
552  typename boost::mpl::and_<
553  typename boost::mpl::equal_to<
554  boost::mpl::sizeof_<TOut>,
555  boost::mpl::int_<4>
556  >::type,
557  typename boost::is_integral<TOut>::type
558  >::type
559  >::type
560  >::type
561 >
562 {
563  static IPSDK_FORCEINLINE
564  void act(
565  const typename RegMaskType<eInstructionSet::eIS_Avx2, TIn>::Type& in0,
566  const typename RegMaskType<eInstructionSet::eIS_Avx2, TIn>::Type& in1,
567  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out)
568  {
569  typename RegType<eInstructionSet::eIS_Avx2, TOut>::Type zero;
570  AssignReg<eInstructionSet::eIS_Avx2, TOut>::act(zero, 0);
571  CastReg<eInstructionSet::eIS_Avx2, ipInt64, ipInt32>::act(in0, in1, out);
572  IsNotEqualReg<eInstructionSet::eIS_Avx2, TOut>::act(out, zero, out);
573  }
574 };*/
575 
578 template <typename TOut>
579 struct MaskCastReg<
580  eInstructionSet::eIS_Avx2,
581  ipReal64,
582  TOut,
583  typename boost::enable_if<
584  typename boost::mpl::and_<
585  typename boost::mpl::equal_to<
586  boost::mpl::sizeof_<TOut>,
587  boost::mpl::int_<4>
588  >::type,
589  typename boost::is_integral<TOut>::type
590  >::type
591  >::type
592 >
593 {
594  static IPSDK_FORCEINLINE
595  void act(
596  const RegMaskType<eInstructionSet::eIS_Avx2, ipReal64>::Type& in0,
597  const RegMaskType<eInstructionSet::eIS_Avx2, ipReal64>::Type& in1,
598  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out)
599  {
600  /*typename RegType<eInstructionSet::eIS_Avx2, ipInt64>::Type in0I, in1I;
601  BitwiseCastReg<eInstructionSet::eIS_Avx2, ipReal64, ipInt64>::act(in0, in0I);
602  BitwiseCastReg<eInstructionSet::eIS_Avx2, ipReal64, ipInt64>::act(in1, in1I);
603  MaskCastReg<eInstructionSet::eIS_Avx2, ipInt64, TOut>::act(in0I, in1I, out);*/
604  RegType<eInstructionSet::eIS_Avx2, ipReal32>::Type outF32;
605  CastReg<eInstructionSet::eIS_Avx2, ipReal64, ipReal32>::act(in0, in1, outF32);
606  MaskCastReg<eInstructionSet::eIS_Avx2, ipReal32, TOut>::act(outF32, out);
607  }
608 };
609 
612 template <>
613 struct MaskCastReg<eInstructionSet::eIS_Avx2, ipReal64, ipReal32>
614 {
615  static IPSDK_FORCEINLINE
616  void act(
617  const RegMaskType<eInstructionSet::eIS_Avx2, ipReal64>::Type& in0,
618  const RegMaskType<eInstructionSet::eIS_Avx2, ipReal64>::Type& in1,
619  RegMaskType<eInstructionSet::eIS_Avx2, ipReal32>::Type& out)
620  {
621  CastReg<eInstructionSet::eIS_Avx2, ipReal64, ipReal32>::act(in0, in1, out);
622 
623  RegType<eInstructionSet::eIS_Avx2, ipReal32>::Type zero;
624  AssignReg<eInstructionSet::eIS_Avx2, ipReal32>::act(zero, 0);
625  IsNotEqualReg<eInstructionSet::eIS_Avx2, ipReal32>::act(out, zero, out);
626  }
627 };
628 
631 template <typename TIn>
632 struct MaskCastReg<
633  eInstructionSet::eIS_Avx2,
634  TIn,
635  ipReal32,
636  typename boost::enable_if<
637  typename boost::mpl::and_<
638  typename boost::mpl::equal_to<
639  boost::mpl::sizeof_<TIn>,
640  boost::mpl::int_<8>
641  >::type,
642  typename boost::is_integral<TIn>::type
643  >::type
644  >::type
645 >
646 {
647  static IPSDK_FORCEINLINE
648  void act(
649  const typename RegMaskType<eInstructionSet::eIS_Avx2, TIn>::Type& in0,
650  const typename RegMaskType<eInstructionSet::eIS_Avx2, TIn>::Type& in1,
651  RegMaskType<eInstructionSet::eIS_Avx2, ipReal32>::Type& out)
652  {
653  RegMaskType<eInstructionSet::eIS_Avx2, ipInt32>::Type outI;
654  MaskCastReg<eInstructionSet::eIS_Avx2, TIn, ipInt32>::act(in0, in1, outI);
655  BitwiseCastReg<eInstructionSet::eIS_Avx2, ipInt32, ipReal32>::act(outI, out);
656  }
657 };
658 
661 template <typename TIn, typename TOut>
662 struct MaskCastReg<
663  eInstructionSet::eIS_Avx2,
664  TIn,
665  TOut,
666  typename boost::enable_if<
667  typename boost::mpl::and_<
668  typename boost::mpl::and_<
669  typename boost::mpl::equal_to<
670  boost::mpl::sizeof_<TIn>,
671  boost::mpl::int_<8>
672  >::type,
673  typename boost::is_integral<TIn>::type
674  >::type,
675  typename boost::mpl::and_<
676  typename boost::mpl::equal_to<
677  boost::mpl::sizeof_<TOut>,
678  boost::mpl::int_<2>
679  >::type,
680  typename boost::is_integral<TOut>::type
681  >::type
682  >::type
683  >::type
684 >
685 {
686  static IPSDK_FORCEINLINE
687  void act(
688  const typename RegMaskType<eInstructionSet::eIS_Avx2, TIn>::Type& in0,
689  const typename RegMaskType<eInstructionSet::eIS_Avx2, TIn>::Type& in1,
690  const typename RegMaskType<eInstructionSet::eIS_Avx2, TIn>::Type& in2,
691  const typename RegMaskType<eInstructionSet::eIS_Avx2, TIn>::Type& in3,
692  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out)
693  {
694  RegMaskType<eInstructionSet::eIS_Avx2, ipInt32>::Type out0, out1;
695  MaskCastReg<eInstructionSet::eIS_Avx2, TIn, ipInt32>::act(in0, in1, out0);
696  MaskCastReg<eInstructionSet::eIS_Avx2, TIn, ipInt32>::act(in2, in3, out1);
697  MaskCastReg<eInstructionSet::eIS_Avx2, ipInt32, ipInt16>::act(out0, out1, out);
698  }
699 };
700 
703 template <typename TOut>
704 struct MaskCastReg<
705  eInstructionSet::eIS_Avx2,
706  ipReal64,
707  TOut,
708  typename boost::enable_if<
709  typename boost::mpl::and_<
710  typename boost::mpl::equal_to<
711  boost::mpl::sizeof_<TOut>,
712  boost::mpl::int_<2>
713  >::type,
714  typename boost::is_integral<TOut>::type
715  >::type
716  >::type
717 >
718 {
719  static IPSDK_FORCEINLINE
720  void act(
721  const RegMaskType<eInstructionSet::eIS_Avx2, ipReal64>::Type& in0,
722  const RegMaskType<eInstructionSet::eIS_Avx2, ipReal64>::Type& in1,
723  const RegMaskType<eInstructionSet::eIS_Avx2, ipReal64>::Type& in2,
724  const RegMaskType<eInstructionSet::eIS_Avx2, ipReal64>::Type& in3,
725  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out)
726  {
727 
728  /*RegMaskType<eInstructionSet::eIS_Avx2, ipInt64>::Type in0I, in1I, in2I, in3I;
729  BitwiseCastReg<eInstructionSet::eIS_Avx2, ipReal64, ipInt64>::act(in0, in0I);
730  BitwiseCastReg<eInstructionSet::eIS_Avx2, ipReal64, ipInt64>::act(in1, in1I);
731  BitwiseCastReg<eInstructionSet::eIS_Avx2, ipReal64, ipInt64>::act(in2, in2I);
732  BitwiseCastReg<eInstructionSet::eIS_Avx2, ipReal64, ipInt64>::act(in3, in3I);
733 
734  MaskCastReg<eInstructionSet::eIS_Avx2, ipInt64, TOut>::act(
735  in0I, in1I, in2I, in3I, out);*/
736  RegMaskType<eInstructionSet::eIS_Avx2, ipInt32>::Type out0F32, out1F32;
737  MaskCastReg<eInstructionSet::eIS_Avx2, ipReal64, ipInt32>::act(in0, in1, out0F32);
738  MaskCastReg<eInstructionSet::eIS_Avx2, ipReal64, ipInt32>::act(in2, in3, out1F32);
739  MaskCastReg<eInstructionSet::eIS_Avx2, ipInt32, TOut>::act(out0F32, out1F32, out);
740  }
741 };
742 
745 template <typename TIn, typename TOut>
746 struct MaskCastReg<
747  eInstructionSet::eIS_Avx2,
748  TIn,
749  TOut,
750  typename boost::enable_if<
751  typename boost::mpl::and_<
752  typename boost::mpl::and_<
753  typename boost::mpl::equal_to<
754  boost::mpl::sizeof_<TIn>,
755  boost::mpl::int_<8>
756  >::type,
757  typename boost::is_integral<TIn>::type
758  >::type,
759  typename boost::mpl::and_<
760  typename boost::mpl::equal_to<
761  boost::mpl::sizeof_<TOut>,
762  boost::mpl::int_<1>
763  >::type,
764  typename boost::is_integral<TOut>::type
765  >::type
766  >::type
767  >::type
768 >
769 {
770  static IPSDK_FORCEINLINE
771  void act(
772  const typename RegMaskType<eInstructionSet::eIS_Avx2, TIn>::Type& in0,
773  const typename RegMaskType<eInstructionSet::eIS_Avx2, TIn>::Type& in1,
774  const typename RegMaskType<eInstructionSet::eIS_Avx2, TIn>::Type& in2,
775  const typename RegMaskType<eInstructionSet::eIS_Avx2, TIn>::Type& in3,
776  const typename RegMaskType<eInstructionSet::eIS_Avx2, TIn>::Type& in4,
777  const typename RegMaskType<eInstructionSet::eIS_Avx2, TIn>::Type& in5,
778  const typename RegMaskType<eInstructionSet::eIS_Avx2, TIn>::Type& in6,
779  const typename RegMaskType<eInstructionSet::eIS_Avx2, TIn>::Type& in7,
780  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out)
781  {
782  RegMaskType<eInstructionSet::eIS_Avx2, ipInt32>::Type out0, out1, out2, out3;
783  MaskCastReg<eInstructionSet::eIS_Avx2, TIn, ipInt32>::act(in0, in1, out0);
784  MaskCastReg<eInstructionSet::eIS_Avx2, TIn, ipInt32>::act(in2, in3, out1);
785  MaskCastReg<eInstructionSet::eIS_Avx2, TIn, ipInt32>::act(in4, in5, out2);
786  MaskCastReg<eInstructionSet::eIS_Avx2, TIn, ipInt32>::act(in6, in7, out3);
787  MaskCastReg<eInstructionSet::eIS_Avx2, ipInt32, ipInt8>::act(out0, out1, out2, out3, out);
788  }
789 };
790 
793 template <typename TOut>
794 struct MaskCastReg<
795  eInstructionSet::eIS_Avx2,
796  ipReal64,
797  TOut,
798  typename boost::enable_if<
799  typename boost::mpl::and_<
800  typename boost::mpl::equal_to<
801  boost::mpl::sizeof_<TOut>,
802  boost::mpl::int_<1>
803  >::type,
804  typename boost::is_integral<TOut>::type
805  >::type
806  >::type
807 >
808 {
809  static IPSDK_FORCEINLINE
810  void act(
811  const RegMaskType<eInstructionSet::eIS_Avx2, ipReal64>::Type& in0,
812  const RegMaskType<eInstructionSet::eIS_Avx2, ipReal64>::Type& in1,
813  const RegMaskType<eInstructionSet::eIS_Avx2, ipReal64>::Type& in2,
814  const RegMaskType<eInstructionSet::eIS_Avx2, ipReal64>::Type& in3,
815  const RegMaskType<eInstructionSet::eIS_Avx2, ipReal64>::Type& in4,
816  const RegMaskType<eInstructionSet::eIS_Avx2, ipReal64>::Type& in5,
817  const RegMaskType<eInstructionSet::eIS_Avx2, ipReal64>::Type& in6,
818  const RegMaskType<eInstructionSet::eIS_Avx2, ipReal64>::Type& in7,
819  typename RegMaskType<eInstructionSet::eIS_Avx2, TOut>::Type& out)
820  {
821 
822  /*RegMaskType<eInstructionSet::eIS_Avx2, ipInt64>::Type in0I, in1I, in2I, in3I,
823  in4I, in5I, in6I, in7I;
824  BitwiseCastReg<eInstructionSet::eIS_Avx2, ipReal64, ipInt64>::act(in0, in0I);
825  BitwiseCastReg<eInstructionSet::eIS_Avx2, ipReal64, ipInt64>::act(in1, in1I);
826  BitwiseCastReg<eInstructionSet::eIS_Avx2, ipReal64, ipInt64>::act(in2, in2I);
827  BitwiseCastReg<eInstructionSet::eIS_Avx2, ipReal64, ipInt64>::act(in3, in3I);
828  BitwiseCastReg<eInstructionSet::eIS_Avx2, ipReal64, ipInt64>::act(in4, in4I);
829  BitwiseCastReg<eInstructionSet::eIS_Avx2, ipReal64, ipInt64>::act(in5, in5I);
830  BitwiseCastReg<eInstructionSet::eIS_Avx2, ipReal64, ipInt64>::act(in6, in6I);
831  BitwiseCastReg<eInstructionSet::eIS_Avx2, ipReal64, ipInt64>::act(in7, in7I);
832 
833  MaskCastReg<eInstructionSet::eIS_Avx2, ipInt64, TOut>::act(
834  in0I, in1I, in2I, in3I, in4I, in5I, in6I, in7I, out);*/
835  RegMaskType<eInstructionSet::eIS_Avx2, ipInt32>::Type out0I32, out1I32, out2I32, out3I32;
836  MaskCastReg<eInstructionSet::eIS_Avx2, ipReal64, ipInt32>::act(in0, in1, out0I32);
837  MaskCastReg<eInstructionSet::eIS_Avx2, ipReal64, ipInt32>::act(in2, in3, out1I32);
838  MaskCastReg<eInstructionSet::eIS_Avx2, ipReal64, ipInt32>::act(in4, in5, out2I32);
839  MaskCastReg<eInstructionSet::eIS_Avx2, ipReal64, ipInt32>::act(in6, in7, out3I32);
840  MaskCastReg<eInstructionSet::eIS_Avx2, ipInt32, ipInt8>::act(out0I32, out1I32, out2I32, out3I32, out);
841  }
842 };
845 
846 } // end of namespace detail
847 } // end of namespace simd
848 } // end of namespace ipsdk
849 
850 #endif // __IPSDKUTIL_INSTRUCTIONSET_DETAIL_AVX2_MASKCASTREG_H__
ipsdk::simd::detail::MaskCastReg
Definition: MaskCastReg.h:30
ForceInline.h
Defines the IPSDK_FORCEINLINE.
ipsdk
Main namespace for IPSDK library.
Definition: AlgorithmFunctionEfficiency.h:22
ipsdk::ipReal64
double ipReal64
Base types definition.
Definition: BaseTypes.h:57
ipsdk::simd::detail::CastReg
Definition: CastReg.h:30
ipsdk::eInstructionSet
eInstructionSet
Enumerate for processor instruction set description.
Definition: InstructionSetTypes.h:31
ipsdk::UpperType
template structure UpperType<typename T>; its typedef Type gives the type just upper to T...
Definition: UpperType.h:42
ipsdk::eIS_Avx2
Advanced Vector Extensions 2.
Definition: InstructionSetTypes.h:48
RegMaskType.h
RegMaskType class.
IPSDKUtilExports.h
Definition of import/export macro for library.
ipsdk::simd::detail::IsNotEqualReg
Definition: IsNotEqualRegDecl.h:30
ipsdk::simd::RegMaskType
Definition: RegMaskType.h:29
ipsdk::simd::detail::BitwiseCastReg
Definition: BitwiseCastReg.h:29
ipsdk::simd::RegType
Definition: RegType.h:29
ipsdk::simd::detail::AssignReg
Definition: AssignRegDecl.h:31
ipsdk::ipReal32
float ipReal32
Base types definition.
Definition: BaseTypes.h:56
Generated on Tue Apr 15 2025 16:20:43 for IPSDK by   doxygen 1.8.14