Cycles: Remove unneeded include statements
[blender-staging.git] / intern / cycles / util / util_simd.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_SIMD_TYPES_H__
19 #define __UTIL_SIMD_TYPES_H__
20
21 #ifndef __KERNEL_GPU__
22
23 #include <limits>
24
25 #include "util/util_defines.h"
26
27 /* SSE Intrinsics includes
28  *
29  * We assume __KERNEL_SSEX__ flags to have been defined at this point */
30
31 /* SSE intrinsics headers */
32 #ifndef FREE_WINDOWS64
33
34 #ifdef _MSC_VER
35 #  include <intrin.h>
36 #elif (defined(__x86_64__) || defined(__i386__))
37 #  include <x86intrin.h>
38 #endif
39
40 #else
41
42 /* MinGW64 has conflicting declarations for these SSE headers in <windows.h>.
43  * Since we can't avoid including <windows.h>, better only include that */
44 #include "util/util_windows.h"
45
46 #endif
47
48 CCL_NAMESPACE_BEGIN
49
50 #ifdef __KERNEL_SSE2__
51
52 extern const __m128 _mm_lookupmask_ps[16];
53
54 /* Special Types */
55
56 static struct TrueTy {
57 __forceinline operator bool( ) const { return true; }
58 } True ccl_maybe_unused;
59
60 static struct FalseTy {
61 __forceinline operator bool( ) const { return false; }
62 } False ccl_maybe_unused;
63
64 static struct NegInfTy
65 {
66 __forceinline operator          float    ( ) const { return -std::numeric_limits<float>::infinity(); }
67 __forceinline operator          int      ( ) const { return std::numeric_limits<int>::min(); }
68 } neg_inf ccl_maybe_unused;
69
70 static struct PosInfTy
71 {
72 __forceinline operator          float    ( ) const { return std::numeric_limits<float>::infinity(); }
73 __forceinline operator          int      ( ) const { return std::numeric_limits<int>::max(); }
74 } inf ccl_maybe_unused, pos_inf ccl_maybe_unused;
75
76 /* Intrinsics Functions */
77
78 #if defined(__BMI__) && defined(__GNUC__)
79 #  ifndef _tzcnt_u32
80 #    define _tzcnt_u32 __tzcnt_u32
81 #  endif
82 #  ifndef _tzcnt_u64
83 #    define _tzcnt_u64 __tzcnt_u64
84 #  endif
85 #endif
86
87 #if defined(__LZCNT__)
88 #define _lzcnt_u32 __lzcnt32
89 #define _lzcnt_u64 __lzcnt64
90 #endif
91
92 #if defined(_WIN32) && !defined(__MINGW32__) && !defined(__clang__)
93
94 __forceinline int __popcnt(int in) {
95   return _mm_popcnt_u32(in);
96 }
97
98 #if !defined(_MSC_VER)
99 __forceinline unsigned int __popcnt(unsigned int in) {
100   return _mm_popcnt_u32(in);
101 }
102 #endif
103
104 #if defined(__KERNEL_64_BIT__)
105 __forceinline long long __popcnt(long long in) {
106   return _mm_popcnt_u64(in);
107 }
108 __forceinline size_t __popcnt(size_t in) {
109   return _mm_popcnt_u64(in);
110 }
111 #endif
112
113 __forceinline int __bsf(int v) {
114 #if defined(__KERNEL_AVX2__) 
115   return _tzcnt_u32(v);
116 #else
117   unsigned long r = 0; _BitScanForward(&r,v); return r;
118 #endif
119 }
120
121 __forceinline unsigned int __bsf(unsigned int v) {
122 #if defined(__KERNEL_AVX2__) 
123   return _tzcnt_u32(v);
124 #else
125   unsigned long r = 0; _BitScanForward(&r,v); return r;
126 #endif
127 }
128
129 __forceinline int __bsr(int v) {
130   unsigned long r = 0; _BitScanReverse(&r,v); return r;
131 }
132
133 __forceinline int __btc(int v, int i) {
134   long r = v; _bittestandcomplement(&r,i); return r;
135 }
136
137 __forceinline int __bts(int v, int i) {
138   long r = v; _bittestandset(&r,i); return r;
139 }
140
141 __forceinline int __btr(int v, int i) {
142   long r = v; _bittestandreset(&r,i); return r;
143 }
144
145 __forceinline int bitscan(int v) {
146 #if defined(__KERNEL_AVX2__) 
147   return _tzcnt_u32(v);
148 #else
149   return __bsf(v);
150 #endif
151 }
152
153 __forceinline int clz(const int x)
154 {
155 #if defined(__KERNEL_AVX2__)
156   return _lzcnt_u32(x);
157 #else
158   if(UNLIKELY(x == 0)) return 32;
159   return 31 - __bsr(x);    
160 #endif
161 }
162
163 __forceinline int __bscf(int& v) 
164 {
165   int i = __bsf(v);
166   v &= v-1;
167   return i;
168 }
169
170 __forceinline unsigned int __bscf(unsigned int& v) 
171 {
172   unsigned int i = __bsf(v);
173   v &= v-1;
174   return i;
175 }
176
177 #if defined(__KERNEL_64_BIT__)
178
179 __forceinline size_t __bsf(size_t v) {
180 #if defined(__KERNEL_AVX2__) 
181   return _tzcnt_u64(v);
182 #else
183   unsigned long r = 0; _BitScanForward64(&r,v); return r;
184 #endif
185 }
186
187 __forceinline size_t __bsr(size_t v) {
188   unsigned long r = 0; _BitScanReverse64(&r,v); return r;
189 }
190
191 __forceinline size_t __btc(size_t v, size_t i) {
192   size_t r = v; _bittestandcomplement64((__int64*)&r,i); return r;
193 }
194
195 __forceinline size_t __bts(size_t v, size_t i) {
196   __int64 r = v; _bittestandset64(&r,i); return r;
197 }
198
199 __forceinline size_t __btr(size_t v, size_t i) {
200   __int64 r = v; _bittestandreset64(&r,i); return r;
201 }
202
203 __forceinline size_t bitscan(size_t v) {
204 #if defined(__KERNEL_AVX2__)
205 #if defined(__KERNEL_64_BIT__)
206   return _tzcnt_u64(v);
207 #else
208   return _tzcnt_u32(v);
209 #endif
210 #else
211   return __bsf(v);
212 #endif
213 }
214
215 __forceinline size_t __bscf(size_t& v) 
216 {
217   size_t i = __bsf(v);
218   v &= v-1;
219   return i;
220 }
221
222 #endif /* __KERNEL_64_BIT__ */
223
224 #else /* _WIN32 */
225
226 __forceinline unsigned int __popcnt(unsigned int in) {
227   int r = 0; asm ("popcnt %1,%0" : "=r"(r) : "r"(in)); return r;
228 }
229
230 __forceinline int __bsf(int v) {
231   int r = 0; asm ("bsf %1,%0" : "=r"(r) : "r"(v)); return r;
232 }
233
234 __forceinline int __bsr(int v) {
235   int r = 0; asm ("bsr %1,%0" : "=r"(r) : "r"(v)); return r;
236 }
237
238 __forceinline int __btc(int v, int i) {
239   int r = 0; asm ("btc %1,%0" : "=r"(r) : "r"(i), "0"(v) : "flags" ); return r;
240 }
241
242 __forceinline int __bts(int v, int i) {
243   int r = 0; asm ("bts %1,%0" : "=r"(r) : "r"(i), "0"(v) : "flags"); return r;
244 }
245
246 __forceinline int __btr(int v, int i) {
247   int r = 0; asm ("btr %1,%0" : "=r"(r) : "r"(i), "0"(v) : "flags"); return r;
248 }
249
250 #if (defined(__KERNEL_64_BIT__) || defined(__APPLE__)) && !(defined(__ILP32__) && defined(__x86_64__))
251 __forceinline size_t __bsf(size_t v) {
252   size_t r = 0; asm ("bsf %1,%0" : "=r"(r) : "r"(v)); return r;
253 }
254 #endif
255
256 __forceinline unsigned int __bsf(unsigned int v) {
257   unsigned int r = 0; asm ("bsf %1,%0" : "=r"(r) : "r"(v)); return r;
258 }
259
260 __forceinline size_t __bsr(size_t v) {
261   size_t r = 0; asm ("bsr %1,%0" : "=r"(r) : "r"(v)); return r;
262 }
263
264 __forceinline size_t __btc(size_t v, size_t i) {
265   size_t r = 0; asm ("btc %1,%0" : "=r"(r) : "r"(i), "0"(v) : "flags" ); return r;
266 }
267
268 __forceinline size_t __bts(size_t v, size_t i) {
269   size_t r = 0; asm ("bts %1,%0" : "=r"(r) : "r"(i), "0"(v) : "flags"); return r;
270 }
271
272 __forceinline size_t __btr(size_t v, size_t i) {
273   size_t r = 0; asm ("btr %1,%0" : "=r"(r) : "r"(i), "0"(v) : "flags"); return r;
274 }
275
276 __forceinline int bitscan(int v) {
277 #if defined(__KERNEL_AVX2__) 
278   return _tzcnt_u32(v);
279 #else
280   return __bsf(v);
281 #endif
282 }
283
284 __forceinline unsigned int bitscan(unsigned int v) {
285 #if defined(__KERNEL_AVX2__) 
286   return _tzcnt_u32(v);
287 #else
288   return __bsf(v);
289 #endif
290 }
291
292 #if (defined(__KERNEL_64_BIT__) || defined(__APPLE__)) && !(defined(__ILP32__) && defined(__x86_64__))
293 __forceinline size_t bitscan(size_t v) {
294 #if defined(__KERNEL_AVX2__)
295 #if defined(__KERNEL_64_BIT__)
296   return _tzcnt_u64(v);
297 #else
298   return _tzcnt_u32(v);
299 #endif
300 #else
301   return __bsf(v);
302 #endif
303 }
304 #endif
305
306 __forceinline int clz(const int x)
307 {
308 #if defined(__KERNEL_AVX2__)
309   return _lzcnt_u32(x);
310 #else
311   if(UNLIKELY(x == 0)) return 32;
312   return 31 - __bsr(x);    
313 #endif
314 }
315
316 __forceinline int __bscf(int& v) 
317 {
318   int i = bitscan(v);
319 #if defined(__KERNEL_AVX2__)
320   v &= v-1;
321 #else
322   v = __btc(v,i);
323 #endif
324   return i;
325 }
326
327 __forceinline unsigned int __bscf(unsigned int& v) 
328 {
329   unsigned int i = bitscan(v);
330   v &= v-1;
331   return i;
332 }
333
334 #if (defined(__KERNEL_64_BIT__) || defined(__APPLE__)) && !(defined(__ILP32__) && defined(__x86_64__))
335 __forceinline size_t __bscf(size_t& v) 
336 {
337   size_t i = bitscan(v);
338 #if defined(__KERNEL_AVX2__)
339   v &= v-1;
340 #else
341   v = __btc(v,i);
342 #endif
343   return i;
344 }
345 #endif
346
347 #endif /* _WIN32 */
348
349 /* Test __KERNEL_SSE41__ for MSVC which does not define __SSE4_1__, and test
350  * __SSE4_1__ to avoid OpenImageIO conflicts with our emulation macros on other
351  * platforms when compiling code outside the kernel. */
352 #if !(defined(__KERNEL_SSE41__) || defined(__SSE4_1__) || defined(__SSE4_2__))
353
354 /* Emulation of SSE4 functions with SSE2 */
355
356 #define _MM_FROUND_TO_NEAREST_INT    0x00
357 #define _MM_FROUND_TO_NEG_INF        0x01
358 #define _MM_FROUND_TO_POS_INF        0x02
359 #define _MM_FROUND_TO_ZERO           0x03
360 #define _MM_FROUND_CUR_DIRECTION     0x04
361
362 #undef _mm_blendv_ps
363 #define _mm_blendv_ps _mm_blendv_ps_emu
364 __forceinline __m128 _mm_blendv_ps_emu( __m128 value, __m128 input, __m128 mask)
365 {
366     __m128i isignmask = _mm_set1_epi32(0x80000000);
367     __m128 signmask = _mm_castsi128_ps(isignmask);
368     __m128i iandsign = _mm_castps_si128(_mm_and_ps(mask, signmask));
369     __m128i icmpmask = _mm_cmpeq_epi32(iandsign, isignmask);
370     __m128 cmpmask = _mm_castsi128_ps(icmpmask);
371     return _mm_or_ps(_mm_and_ps(cmpmask, input), _mm_andnot_ps(cmpmask, value));
372 }
373
374 #undef _mm_blend_ps
375 #define _mm_blend_ps _mm_blend_ps_emu
376 __forceinline __m128 _mm_blend_ps_emu( __m128 value, __m128 input, const int mask)
377 {
378     assert(mask < 0x10); return _mm_blendv_ps(value, input, _mm_lookupmask_ps[mask]); 
379 }
380
381 #undef _mm_blendv_epi8
382 #define _mm_blendv_epi8 _mm_blendv_epi8_emu
383 __forceinline __m128i _mm_blendv_epi8_emu( __m128i value, __m128i input, __m128i mask)
384 {
385     return _mm_or_si128(_mm_and_si128(mask, input), _mm_andnot_si128(mask, value)); 
386 }
387
388 #undef _mm_min_epi32
389 #define _mm_min_epi32 _mm_min_epi32_emu
390 __forceinline __m128i _mm_min_epi32_emu( __m128i value, __m128i input)
391 {
392     return _mm_blendv_epi8(input, value, _mm_cmplt_epi32(value, input)); 
393 }
394
395 #undef _mm_max_epi32
396 #define _mm_max_epi32 _mm_max_epi32_emu
397 __forceinline __m128i _mm_max_epi32_emu( __m128i value, __m128i input)
398 {
399     return _mm_blendv_epi8(value, input, _mm_cmplt_epi32(value, input)); 
400 }
401
402 #undef _mm_extract_epi32
403 #define _mm_extract_epi32 _mm_extract_epi32_emu
404 __forceinline int _mm_extract_epi32_emu( __m128i input, const int index)
405 {
406   switch(index) {
407   case 0: return _mm_cvtsi128_si32(input);
408   case 1: return _mm_cvtsi128_si32(_mm_shuffle_epi32(input, _MM_SHUFFLE(1, 1, 1, 1)));
409   case 2: return _mm_cvtsi128_si32(_mm_shuffle_epi32(input, _MM_SHUFFLE(2, 2, 2, 2)));
410   case 3: return _mm_cvtsi128_si32(_mm_shuffle_epi32(input, _MM_SHUFFLE(3, 3, 3, 3)));
411   default: assert(false); return 0;
412   }
413 }
414
415 #undef _mm_insert_epi32
416 #define _mm_insert_epi32 _mm_insert_epi32_emu
417 __forceinline __m128i _mm_insert_epi32_emu( __m128i value, int input, const int index)
418 {
419     assert(index >= 0 && index < 4); ((int*)&value)[index] = input; return value; 
420 }
421
422 #undef _mm_insert_ps
423 #define _mm_insert_ps _mm_insert_ps_emu
424 __forceinline __m128 _mm_insert_ps_emu( __m128 value, __m128 input, const int index)
425 {
426         assert(index < 0x100);
427         ((float*)&value)[(index >> 4)&0x3] = ((float*)&input)[index >> 6];
428         return _mm_andnot_ps(_mm_lookupmask_ps[index&0xf], value);
429 }
430
431 #undef _mm_round_ps
432 #define _mm_round_ps _mm_round_ps_emu
433 __forceinline __m128 _mm_round_ps_emu( __m128 value, const int flags)
434 {
435   switch(flags)
436   {
437   case _MM_FROUND_TO_NEAREST_INT: return _mm_cvtepi32_ps(_mm_cvtps_epi32(value));
438   case _MM_FROUND_TO_NEG_INF    : return _mm_cvtepi32_ps(_mm_cvtps_epi32(_mm_add_ps(value, _mm_set1_ps(-0.5f))));
439   case _MM_FROUND_TO_POS_INF    : return _mm_cvtepi32_ps(_mm_cvtps_epi32(_mm_add_ps(value, _mm_set1_ps( 0.5f))));
440   case _MM_FROUND_TO_ZERO       : return _mm_cvtepi32_ps(_mm_cvttps_epi32(value));
441   }
442   return value;
443 }
444
445 #endif /* !(defined(__KERNEL_SSE41__) || defined(__SSE4_1__) || defined(__SSE4_2__)) */
446
447 #else  /* __KERNEL_SSE2__ */
448
449 /* This section is for utility functions which operates on non-register data
450  * which might be used from a non-vectorized code.
451  */
452
453 ccl_device_inline int bitscan(int value)
454 {
455         assert(value != 0);
456         int bit = 0;
457         while(value >>= 1) {
458                 ++bit;
459         }
460         return bit;
461 }
462
463
464 #endif /* __KERNEL_SSE2__ */
465
466 /* quiet unused define warnings */
467 #if defined(__KERNEL_SSE2__)  || \
468         defined(__KERNEL_SSE3__)  || \
469         defined(__KERNEL_SSSE3__) || \
470         defined(__KERNEL_SSE41__) || \
471         defined(__KERNEL_AVX__)   || \
472         defined(__KERNEL_AVX2__)
473         /* do nothing */
474 #endif
475
476 CCL_NAMESPACE_END
477
478 #endif /* __KERNEL_GPU__ */
479
480 #endif /* __UTIL_SIMD_TYPES_H__ */
481