ClangFormat: apply to source, most of intern
[blender.git] / intern / cycles / util / util_avxb.h
1 /*
2  * Copyright 2011-2013 Intel Corporation
3  * Modifications Copyright 2014, Blender Foundation.
4  *
5  * Licensed under the Apache License, Version 2.0(the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17
18 #ifndef __UTIL_AVXB_H__
19 #  define __UTIL_AVXB_H__
20
21 CCL_NAMESPACE_BEGIN
22
23 struct avxf;
24
25 /*! 4-wide SSE bool type. */
26 struct avxb {
27   typedef avxb Mask;   // mask type
28   typedef avxf Float;  // float type
29
30   enum { size = 8 };  // number of SIMD elements
31   union {
32     __m256 m256;
33     int32_t v[8];
34   };  // data
35
36   ////////////////////////////////////////////////////////////////////////////////
37   /// Constructors, Assignment & Cast Operators
38   ////////////////////////////////////////////////////////////////////////////////
39
40   __forceinline avxb()
41   {
42   }
43   __forceinline avxb(const avxb &other)
44   {
45     m256 = other.m256;
46   }
47   __forceinline avxb &operator=(const avxb &other)
48   {
49     m256 = other.m256;
50     return *this;
51   }
52
53   __forceinline avxb(const __m256 input) : m256(input)
54   {
55   }
56   __forceinline operator const __m256 &(void)const
57   {
58     return m256;
59   }
60   __forceinline operator const __m256i(void) const
61   {
62     return _mm256_castps_si256(m256);
63   }
64   __forceinline operator const __m256d(void) const
65   {
66     return _mm256_castps_pd(m256);
67   }
68
69   ////////////////////////////////////////////////////////////////////////////////
70   /// Constants
71   ////////////////////////////////////////////////////////////////////////////////
72
73   __forceinline avxb(FalseTy) : m256(_mm256_setzero_ps())
74   {
75   }
76   __forceinline avxb(TrueTy) : m256(_mm256_castsi256_ps(_mm256_set1_epi32(-1)))
77   {
78   }
79
80   ////////////////////////////////////////////////////////////////////////////////
81   /// Array Access
82   ////////////////////////////////////////////////////////////////////////////////
83
84   __forceinline bool operator[](const size_t i) const
85   {
86     assert(i < 8);
87     return (_mm256_movemask_ps(m256) >> i) & 1;
88   }
89   __forceinline int32_t &operator[](const size_t i)
90   {
91     assert(i < 8);
92     return v[i];
93   }
94 };
95
96 ////////////////////////////////////////////////////////////////////////////////
97 /// Unary Operators
98 ////////////////////////////////////////////////////////////////////////////////
99
100 __forceinline const avxb operator!(const avxb &a)
101 {
102   return _mm256_xor_ps(a, avxb(True));
103 }
104
105 ////////////////////////////////////////////////////////////////////////////////
106 /// Binary Operators
107 ////////////////////////////////////////////////////////////////////////////////
108
109 __forceinline const avxb operator&(const avxb &a, const avxb &b)
110 {
111   return _mm256_and_ps(a, b);
112 }
113 __forceinline const avxb operator|(const avxb &a, const avxb &b)
114 {
115   return _mm256_or_ps(a, b);
116 }
117 __forceinline const avxb operator^(const avxb &a, const avxb &b)
118 {
119   return _mm256_xor_ps(a, b);
120 }
121
122 ////////////////////////////////////////////////////////////////////////////////
123 /// Assignment Operators
124 ////////////////////////////////////////////////////////////////////////////////
125
126 __forceinline const avxb operator&=(avxb &a, const avxb &b)
127 {
128   return a = a & b;
129 }
130 __forceinline const avxb operator|=(avxb &a, const avxb &b)
131 {
132   return a = a | b;
133 }
134 __forceinline const avxb operator^=(avxb &a, const avxb &b)
135 {
136   return a = a ^ b;
137 }
138
139 ////////////////////////////////////////////////////////////////////////////////
140 /// Comparison Operators + Select
141 ////////////////////////////////////////////////////////////////////////////////
142
143 __forceinline const avxb operator!=(const avxb &a, const avxb &b)
144 {
145   return _mm256_xor_ps(a, b);
146 }
147 __forceinline const avxb operator==(const avxb &a, const avxb &b)
148 {
149 #  ifdef __KERNEL_AVX2__
150   return _mm256_castsi256_ps(_mm256_cmpeq_epi32(a, b));
151 #  else
152   __m128i a_lo = _mm_castps_si128(_mm256_extractf128_ps(a, 0));
153   __m128i a_hi = _mm_castps_si128(_mm256_extractf128_ps(a, 1));
154   __m128i b_lo = _mm_castps_si128(_mm256_extractf128_ps(b, 0));
155   __m128i b_hi = _mm_castps_si128(_mm256_extractf128_ps(b, 1));
156   __m128i c_lo = _mm_cmpeq_epi32(a_lo, b_lo);
157   __m128i c_hi = _mm_cmpeq_epi32(a_hi, b_hi);
158   __m256i result = _mm256_insertf128_si256(_mm256_castsi128_si256(c_lo), c_hi, 1);
159   return _mm256_castsi256_ps(result);
160 #  endif
161 }
162
163 __forceinline const avxb select(const avxb &m, const avxb &t, const avxb &f)
164 {
165 #  if defined(__KERNEL_SSE41__)
166   return _mm256_blendv_ps(f, t, m);
167 #  else
168   return _mm256_or_ps(_mm256_and_ps(m, t), _mm256_andnot_ps(m, f));
169 #  endif
170 }
171
172 ////////////////////////////////////////////////////////////////////////////////
173 /// Movement/Shifting/Shuffling Functions
174 ////////////////////////////////////////////////////////////////////////////////
175
176 __forceinline const avxb unpacklo(const avxb &a, const avxb &b)
177 {
178   return _mm256_unpacklo_ps(a, b);
179 }
180 __forceinline const avxb unpackhi(const avxb &a, const avxb &b)
181 {
182   return _mm256_unpackhi_ps(a, b);
183 }
184
185 ////////////////////////////////////////////////////////////////////////////////
186 /// Reduction Operations
187 ////////////////////////////////////////////////////////////////////////////////
188
189 #  if defined(__KERNEL_SSE41__)
190 __forceinline size_t popcnt(const avxb &a)
191 {
192   return __popcnt(_mm256_movemask_ps(a));
193 }
194 #  else
195 __forceinline size_t popcnt(const avxb &a)
196 {
197   return bool(a[0]) + bool(a[1]) + bool(a[2]) + bool(a[3]) + bool(a[4]) + bool(a[5]) + bool(a[6]) +
198          bool(a[7]);
199 }
200 #  endif
201
202 __forceinline bool reduce_and(const avxb &a)
203 {
204   return _mm256_movemask_ps(a) == 0xf;
205 }
206 __forceinline bool reduce_or(const avxb &a)
207 {
208   return _mm256_movemask_ps(a) != 0x0;
209 }
210 __forceinline bool all(const avxb &b)
211 {
212   return _mm256_movemask_ps(b) == 0xf;
213 }
214 __forceinline bool any(const avxb &b)
215 {
216   return _mm256_movemask_ps(b) != 0x0;
217 }
218 __forceinline bool none(const avxb &b)
219 {
220   return _mm256_movemask_ps(b) == 0x0;
221 }
222
223 __forceinline size_t movemask(const avxb &a)
224 {
225   return _mm256_movemask_ps(a);
226 }
227
228 ////////////////////////////////////////////////////////////////////////////////
229 /// Debug Functions
230 ////////////////////////////////////////////////////////////////////////////////
231
232 ccl_device_inline void print_avxb(const char *label, const avxb &a)
233 {
234   printf("%s: %d %d %d %d %d %d %d %d\n", label, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7]);
235 }
236
237 #endif
238
239 CCL_NAMESPACE_END
240
241 //#endif