CoCalc -- vfloat4

GitHub Repository: godotengine/godot
Path: blob/master/thirdparty/embree/common/simd/vfloat4_sse2.h
⁹⁹¹² views
1
// Copyright 2009-2021 Intel Corporation
2
// SPDX-License-Identifier: Apache-2.0
3

4
#pragma once
5

6
#define vboolf vboolf_impl
7
#define vboold vboold_impl
8
#define vint vint_impl
9
#define vuint vuint_impl
10
#define vllong vllong_impl
11
#define vfloat vfloat_impl
12
#define vdouble vdouble_impl
13

14
namespace embree
15
{
16
  /* 4-wide SSE float type */
17
  template<>
18
  struct vfloat<4>
19
  {
20
    ALIGNED_STRUCT_(16);
21
    
22
    typedef vboolf4 Bool;
23
    typedef vint4   Int;
24
    typedef vfloat4 Float;
25
    
26
    enum  { size = 4 };                        // number of SIMD elements
27
    union { __m128 v; float f[4]; int i[4]; }; // data
28

29
    ////////////////////////////////////////////////////////////////////////////////
30
    /// Constructors, Assignment & Cast Operators
31
    ////////////////////////////////////////////////////////////////////////////////
32
    
33
    __forceinline vfloat() {}
34
    __forceinline vfloat(const vfloat4& other) { v = other.v; }
35
    //__forceinline vfloat(const vfloat4& other) = default;
36
    
37
    __forceinline vfloat4& operator =(const vfloat4& other) { v = other.v; return *this; }
38

39
    __forceinline vfloat(__m128 a) : v(a) {}
40
    __forceinline operator const __m128&() const { return v; }
41
    __forceinline operator       __m128&()       { return v; }
42

43
    __forceinline vfloat(float a) : v(_mm_set1_ps(a)) {}
44
    __forceinline vfloat(float a, float b, float c, float d) : v(_mm_set_ps(d, c, b, a)) {}
45

46
    __forceinline explicit vfloat(const vint4& a) : v(_mm_cvtepi32_ps(a)) {}
47
#if defined(__aarch64__)
48
    __forceinline explicit vfloat(const vuint4& x) {
49
        v = vcvtq_f32_u32(vreinterpretq_u32_s32(x.v));
50
    }
51
#else
52
    __forceinline explicit vfloat(const vuint4& x) {
53
      const __m128i a   = _mm_and_si128(x,_mm_set1_epi32(0x7FFFFFFF));
54
      const __m128i b   = _mm_and_si128(_mm_srai_epi32(x,31),_mm_set1_epi32(0x4F000000)); //0x4F000000 = 2^31 
55
      const __m128  af  = _mm_cvtepi32_ps(a);
56
      const __m128  bf  = _mm_castsi128_ps(b);  
57
      v  = _mm_add_ps(af,bf);
58
    }
59
#endif
60
    ////////////////////////////////////////////////////////////////////////////////
61
    /// Constants
62
    ////////////////////////////////////////////////////////////////////////////////
63

64
    __forceinline vfloat(ZeroTy)   : v(_mm_setzero_ps()) {}
65
    __forceinline vfloat(OneTy)    : v(_mm_set1_ps(1.0f)) {}
66
    __forceinline vfloat(PosInfTy) : v(_mm_set1_ps(pos_inf)) {}
67
    __forceinline vfloat(NegInfTy) : v(_mm_set1_ps(neg_inf)) {}
68
    __forceinline vfloat(StepTy)   : v(_mm_set_ps(3.0f, 2.0f, 1.0f, 0.0f)) {}
69
    __forceinline vfloat(NaNTy)    : v(_mm_set1_ps(nan)) {}
70
    __forceinline vfloat(UndefinedTy) : v(_mm_undefined_ps()) {}
71

72
    ////////////////////////////////////////////////////////////////////////////////
73
    /// Loads and Stores
74
    ////////////////////////////////////////////////////////////////////////////////
75

76
    static __forceinline vfloat4 load (const void* a) { return _mm_load_ps((float*)a); }
77
    static __forceinline vfloat4 loadu(const void* a) { return _mm_loadu_ps((float*)a); }
78

79
    static __forceinline void store (void* ptr, const vfloat4& v) { _mm_store_ps((float*)ptr,v); }
80
    static __forceinline void storeu(void* ptr, const vfloat4& v) { _mm_storeu_ps((float*)ptr,v); }
81

82
#if defined(__AVX512VL__)
83

84
    static __forceinline vfloat4 load (const vboolf4& mask, const void* ptr) { return _mm_mask_load_ps (_mm_setzero_ps(),mask,(float*)ptr); }
85
    static __forceinline vfloat4 loadu(const vboolf4& mask, const void* ptr) { return _mm_mask_loadu_ps(_mm_setzero_ps(),mask,(float*)ptr); }
86

87
    static __forceinline void store (const vboolf4& mask, void* ptr, const vfloat4& v) { _mm_mask_store_ps ((float*)ptr,mask,v); }
88
    static __forceinline void storeu(const vboolf4& mask, void* ptr, const vfloat4& v) { _mm_mask_storeu_ps((float*)ptr,mask,v); }
89
#elif defined(__AVX__)
90
    static __forceinline vfloat4 load (const vboolf4& mask, const void* ptr) { return _mm_maskload_ps((float*)ptr,mask); }
91
    static __forceinline vfloat4 loadu(const vboolf4& mask, const void* ptr) { return _mm_maskload_ps((float*)ptr,mask); }
92

93
    static __forceinline void store (const vboolf4& mask, void* ptr, const vfloat4& v) { _mm_maskstore_ps((float*)ptr,(__m128i)mask,v); }
94
    static __forceinline void storeu(const vboolf4& mask, void* ptr, const vfloat4& v) { _mm_maskstore_ps((float*)ptr,(__m128i)mask,v); }
95
#else
96
    static __forceinline vfloat4 load (const vboolf4& mask, const void* ptr) { return _mm_and_ps(_mm_load_ps ((float*)ptr),mask); }
97
    static __forceinline vfloat4 loadu(const vboolf4& mask, const void* ptr) { return _mm_and_ps(_mm_loadu_ps((float*)ptr),mask); }
98

99
    static __forceinline void store (const vboolf4& mask, void* ptr, const vfloat4& v) { store (ptr,select(mask,v,load (ptr))); }
100
    static __forceinline void storeu(const vboolf4& mask, void* ptr, const vfloat4& v) { storeu(ptr,select(mask,v,loadu(ptr))); }
101
#endif
102

103
#if defined(__AVX__)
104
    static __forceinline vfloat4 broadcast(const void* a) { return _mm_broadcast_ss((float*)a); }
105
#else
106
    static __forceinline vfloat4 broadcast(const void* a) { return _mm_set1_ps(*(float*)a); }
107
#endif
108

109
    static __forceinline vfloat4 load_nt (const float* ptr) {
110
#if defined (__SSE4_1__)
111
    return _mm_castsi128_ps(_mm_stream_load_si128((__m128i*)ptr));
112
#else
113
    return _mm_load_ps(ptr); 
114
#endif
115
  }
116

117
#if defined(__aarch64__)
118
    static __forceinline vfloat4 load(const char* ptr) {
119
        return __m128(_mm_load4epi8_f32(((__m128i*)ptr)));
120
    }
121
#elif defined(__SSE4_1__)
122
    static __forceinline vfloat4 load(const char* ptr) {
123
      return _mm_cvtepi32_ps(_mm_cvtepi8_epi32(_mm_loadu_si128((__m128i*)ptr)));
124
    }
125
#else
126
    static __forceinline vfloat4 load(const char* ptr) {
127
      return vfloat4(ptr[0],ptr[1],ptr[2],ptr[3]);
128
    }
129
#endif
130

131
#if defined(__aarch64__)
132
    static __forceinline vfloat4 load(const unsigned char* ptr) {
133
        return __m128(_mm_load4epu8_f32(((__m128i*)ptr)));
134
    }
135
#elif defined(__SSE4_1__)
136
    static __forceinline vfloat4 load(const unsigned char* ptr) {
137
      return _mm_cvtepi32_ps(_mm_cvtepu8_epi32(_mm_loadu_si128((__m128i*)ptr)));
138
    }
139
#else
140
    static __forceinline vfloat4 load(const unsigned char* ptr) {
141
      //return _mm_cvtpu8_ps(*(__m64*)ptr); // don't enable, will use MMX instructions
142
      return vfloat4(ptr[0],ptr[1],ptr[2],ptr[3]);
143
    }
144
#endif
145

146
#if defined(__aarch64__)
147
    static __forceinline vfloat4 load(const short* ptr) {
148
        return __m128(_mm_load4epi16_f32(((__m128i*)ptr)));
149
    }
150
#elif defined(__SSE4_1__)
151
    static __forceinline vfloat4 load(const short* ptr) {
152
      return _mm_cvtepi32_ps(_mm_cvtepi16_epi32(_mm_loadu_si128((__m128i*)ptr)));
153
    }
154
#else
155
    static __forceinline vfloat4 load(const short* ptr) {
156
      return vfloat4(ptr[0],ptr[1],ptr[2],ptr[3]);
157
    }
158
#endif
159

160
    static __forceinline vfloat4 load(const unsigned short* ptr) {
161
      return _mm_mul_ps(vfloat4(vint4::load(ptr)),vfloat4(1.0f/65535.0f));
162
    }
163
    
164
    static __forceinline void store_nt(void* ptr, const vfloat4& v)
165
    {
166
#if defined (__SSE4_1__)
167
#if defined(__aarch64__)
168
      _mm_stream_ps((float*)ptr,v);
169
#else
170
      _mm_stream_ps((float*)ptr,v);
171
#endif
172
#else
173
      _mm_store_ps((float*)ptr,v);
174
#endif
175
    }
176

177
    template<int scale = 4>
178
    static __forceinline vfloat4 gather(const float* ptr, const vint4& index) {
179
#if defined(__AVX2__) && !defined(__aarch64__)
180
      return _mm_i32gather_ps(ptr, index, scale);
181
#else
182
      return vfloat4(
183
        *(float*)(((char*)ptr)+scale*index[0]),
184
        *(float*)(((char*)ptr)+scale*index[1]),
185
        *(float*)(((char*)ptr)+scale*index[2]),
186
        *(float*)(((char*)ptr)+scale*index[3]));
187
#endif
188
    }
189

190
    template<int scale = 4>
191
    static __forceinline vfloat4 gather(const vboolf4& mask, const float* ptr, const vint4& index) {
192
      vfloat4 r = zero;
193
#if defined(__AVX512VL__)
194
      return _mm_mmask_i32gather_ps(r, mask, index, ptr, scale);
195
#elif defined(__AVX2__)  && !defined(__aarch64__)
196
      return _mm_mask_i32gather_ps(r, ptr, index, mask, scale);
197
#else
198
      if (likely(mask[0])) r[0] = *(float*)(((char*)ptr)+scale*index[0]);
199
      if (likely(mask[1])) r[1] = *(float*)(((char*)ptr)+scale*index[1]);
200
      if (likely(mask[2])) r[2] = *(float*)(((char*)ptr)+scale*index[2]);
201
      if (likely(mask[3])) r[3] = *(float*)(((char*)ptr)+scale*index[3]);
202
      return r;
203
#endif
204
    }
205

206
    template<int scale = 4>
207
    static __forceinline void scatter(void* ptr, const vint4& index, const vfloat4& v)
208
    {
209
#if defined(__AVX512VL__)
210
      _mm_i32scatter_ps((float*)ptr, index, v, scale);
211
#else
212
      *(float*)(((char*)ptr)+scale*index[0]) = v[0];
213
      *(float*)(((char*)ptr)+scale*index[1]) = v[1];
214
      *(float*)(((char*)ptr)+scale*index[2]) = v[2];
215
      *(float*)(((char*)ptr)+scale*index[3]) = v[3];
216
#endif
217
    }
218

219
    template<int scale = 4>
220
    static __forceinline void scatter(const vboolf4& mask, void* ptr, const vint4& index, const vfloat4& v)
221
    {
222
#if defined(__AVX512VL__)
223
      _mm_mask_i32scatter_ps((float*)ptr ,mask, index, v, scale);
224
#else
225
      if (likely(mask[0])) *(float*)(((char*)ptr)+scale*index[0]) = v[0];
226
      if (likely(mask[1])) *(float*)(((char*)ptr)+scale*index[1]) = v[1];
227
      if (likely(mask[2])) *(float*)(((char*)ptr)+scale*index[2]) = v[2];
228
      if (likely(mask[3])) *(float*)(((char*)ptr)+scale*index[3]) = v[3];
229
#endif
230
    }
231

232
    static __forceinline void store(const vboolf4& mask, char* ptr, const vint4& ofs, const vfloat4& v) {
233
      scatter<1>(mask,ptr,ofs,v);
234
    }
235
    static __forceinline void store(const vboolf4& mask, float* ptr, const vint4& ofs, const vfloat4& v) {
236
      scatter<4>(mask,ptr,ofs,v);
237
    }
238
    
239
    ////////////////////////////////////////////////////////////////////////////////
240
    /// Array Access
241
    ////////////////////////////////////////////////////////////////////////////////
242

243
    __forceinline const float& operator [](size_t index) const { assert(index < 4); return f[index]; }
244
    __forceinline       float& operator [](size_t index)       { assert(index < 4); return f[index]; }
245

246
    friend __forceinline vfloat4 select(const vboolf4& m, const vfloat4& t, const vfloat4& f) {
247
#if defined(__AVX512VL__)
248
      return _mm_mask_blend_ps(m, f, t);
249
#elif defined(__SSE4_1__) || (defined(__aarch64__))
250
      return _mm_blendv_ps(f, t, m);
251
#else
252
      return _mm_or_ps(_mm_and_ps(m, t), _mm_andnot_ps(m, f)); 
253
#endif
254
    }
255
  };
256

257
  ////////////////////////////////////////////////////////////////////////////////
258
  /// Load/Store
259
  ////////////////////////////////////////////////////////////////////////////////
260

261
  template<> struct mem<vfloat4>
262
  {
263
    static __forceinline vfloat4 load (const vboolf4& mask, const void* ptr) { return vfloat4::load (mask,ptr); }
264
    static __forceinline vfloat4 loadu(const vboolf4& mask, const void* ptr) { return vfloat4::loadu(mask,ptr); }
265
    
266
    static __forceinline void store (const vboolf4& mask, void* ptr, const vfloat4& v) { vfloat4::store (mask,ptr,v); }
267
    static __forceinline void storeu(const vboolf4& mask, void* ptr, const vfloat4& v) { vfloat4::storeu(mask,ptr,v); }
268
  };
269
    
270
  ////////////////////////////////////////////////////////////////////////////////
271
  /// Unary Operators
272
  ////////////////////////////////////////////////////////////////////////////////
273

274
  __forceinline vfloat4 asFloat(const vint4&   a) { return _mm_castsi128_ps(a); }
275
  __forceinline vint4   asInt  (const vfloat4& a) { return _mm_castps_si128(a); }
276
  __forceinline vuint4  asUInt (const vfloat4& a) { return _mm_castps_si128(a); }
277

278
  __forceinline vint4   toInt  (const vfloat4& a) { return vint4(a); }
279
  __forceinline vfloat4 toFloat(const vint4&   a) { return vfloat4(a); }
280

281
  __forceinline vfloat4 operator +(const vfloat4& a) { return a; }
282
#if defined(__aarch64__)
283
  __forceinline vfloat4 operator -(const vfloat4& a) {
284
    return vnegq_f32(a);
285
  }
286
#else
287
  __forceinline vfloat4 operator -(const vfloat4& a) { return _mm_xor_ps(a, _mm_castsi128_ps(_mm_set1_epi32(0x80000000))); }
288
#endif
289

290
#if defined(__aarch64__)
291
  __forceinline vfloat4 abs(const vfloat4& a) { return _mm_abs_ps(a); }
292
#else
293
  __forceinline vfloat4 abs(const vfloat4& a) { return _mm_and_ps(a, _mm_castsi128_ps(_mm_set1_epi32(0x7fffffff))); }
294
#endif
295

296
#if defined(__AVX512VL__)
297
  __forceinline vfloat4 sign(const vfloat4& a) { return _mm_mask_blend_ps(_mm_cmp_ps_mask(a, vfloat4(zero), _CMP_LT_OQ), vfloat4(one), -vfloat4(one)); }
298
#else
299
  __forceinline vfloat4 sign(const vfloat4& a) { return blendv_ps(vfloat4(one), -vfloat4(one), _mm_cmplt_ps(a, vfloat4(zero))); }
300
#endif
301

302
  __forceinline vfloat4 signmsk(const vfloat4& a) { return _mm_and_ps(a,_mm_castsi128_ps(_mm_set1_epi32(0x80000000))); }
303

304
  __forceinline vfloat4 rcp(const vfloat4& a)
305
  {
306
#if defined(__aarch64__)
307
    return vfloat4(vdivq_f32(vdupq_n_f32(1.0f),a.v));
308
#else
309

310
#if defined(__AVX512VL__)
311
    const vfloat4 r = _mm_rcp14_ps(a);
312
#else
313
    const vfloat4 r = _mm_rcp_ps(a);
314
#endif
315

316
#if defined(__AVX2__)
317
    return _mm_fmadd_ps(r, _mm_fnmadd_ps(a, r, vfloat4(1.0f)), r);                    // computes r + r * (1 - a * r)
318
#else
319
    return _mm_add_ps(r,_mm_mul_ps(r, _mm_sub_ps(vfloat4(1.0f), _mm_mul_ps(a, r))));  // computes r + r * (1 - a * r)
320
#endif
321

322
#endif  //defined(__aarch64__)
323
  }
324
  __forceinline vfloat4 sqr (const vfloat4& a) { return _mm_mul_ps(a,a); }
325
  __forceinline vfloat4 sqrt(const vfloat4& a) { return _mm_sqrt_ps(a); }
326

327
  __forceinline vfloat4 rsqrt(const vfloat4& a)
328
  {
329
#if defined(__aarch64__)
330
    vfloat4 r = _mm_rsqrt_ps(a);
331
    r = vmulq_f32(r, vrsqrtsq_f32(vmulq_f32(a, r), r));
332
    r = vmulq_f32(r, vrsqrtsq_f32(vmulq_f32(a, r), r));
333
    r = vmulq_f32(r, vrsqrtsq_f32(vmulq_f32(a, r), r));
334
    return r;
335
#else
336

337
#if defined(__AVX512VL__)
338
    vfloat4 r = _mm_rsqrt14_ps(a);
339
#else
340
    vfloat4 r = _mm_rsqrt_ps(a);
341
#endif
342

343
#if defined(__AVX2__)
344
    r = _mm_fmadd_ps(_mm_set1_ps(1.5f), r, _mm_mul_ps(_mm_mul_ps(_mm_mul_ps(a, _mm_set1_ps(-0.5f)), r), _mm_mul_ps(r, r)));
345
#else
346
    r = _mm_add_ps(_mm_mul_ps(_mm_set1_ps(1.5f), r), _mm_mul_ps(_mm_mul_ps(_mm_mul_ps(a, _mm_set1_ps(-0.5f)), r), _mm_mul_ps(r, r)));
347
#endif
348

349
#endif
350
    return r;
351
  }
352

353
  __forceinline vboolf4 isnan(const vfloat4& a) {
354
    const vfloat4 b = _mm_and_ps(a, _mm_castsi128_ps(_mm_set1_epi32(0x7fffffff)));
355
#if defined(__AVX512VL__)
356
    return _mm_cmp_epi32_mask(_mm_castps_si128(b), _mm_set1_epi32(0x7f800000), _MM_CMPINT_GT);
357
#else
358
    return _mm_castsi128_ps(_mm_cmpgt_epi32(_mm_castps_si128(b), _mm_set1_epi32(0x7f800000)));
359
#endif
360
  }
361

362
  ////////////////////////////////////////////////////////////////////////////////
363
  /// Binary Operators
364
  ////////////////////////////////////////////////////////////////////////////////
365

366
  __forceinline vfloat4 operator +(const vfloat4& a, const vfloat4& b) { return _mm_add_ps(a, b); }
367
  __forceinline vfloat4 operator +(const vfloat4& a, float          b) { return a + vfloat4(b); }
368
  __forceinline vfloat4 operator +(float          a, const vfloat4& b) { return vfloat4(a) + b; }
369

370
  __forceinline vfloat4 operator -(const vfloat4& a, const vfloat4& b) { return _mm_sub_ps(a, b); }
371
  __forceinline vfloat4 operator -(const vfloat4& a, float          b) { return a - vfloat4(b); }
372
  __forceinline vfloat4 operator -(float          a, const vfloat4& b) { return vfloat4(a) - b; }
373

374
  __forceinline vfloat4 operator *(const vfloat4& a, const vfloat4& b) { return _mm_mul_ps(a, b); }
375
  __forceinline vfloat4 operator *(const vfloat4& a, float          b) { return a * vfloat4(b); }
376
  __forceinline vfloat4 operator *(float          a, const vfloat4& b) { return vfloat4(a) * b; }
377

378
  __forceinline vfloat4 operator /(const vfloat4& a, const vfloat4& b) { return _mm_div_ps(a,b); }
379
  __forceinline vfloat4 operator /(const vfloat4& a, float          b) { return a/vfloat4(b); }
380
  __forceinline vfloat4 operator /(float          a, const vfloat4& b) { return vfloat4(a)/b; }
381

382
  __forceinline vfloat4 operator &(const vfloat4& a, const vfloat4& b) { return _mm_and_ps(a,b); }
383
  __forceinline vfloat4 operator |(const vfloat4& a, const vfloat4& b) { return _mm_or_ps(a,b); }
384
  __forceinline vfloat4 operator ^(const vfloat4& a, const vfloat4& b) { return _mm_xor_ps(a,b); }
385
  __forceinline vfloat4 operator ^(const vfloat4& a, const vint4&   b) { return _mm_xor_ps(a,_mm_castsi128_ps(b)); }
386

387
  __forceinline vfloat4 min(const vfloat4& a, const vfloat4& b) { return _mm_min_ps(a,b); }
388
  __forceinline vfloat4 min(const vfloat4& a, float          b) { return _mm_min_ps(a,vfloat4(b)); }
389
  __forceinline vfloat4 min(float          a, const vfloat4& b) { return _mm_min_ps(vfloat4(a),b); }
390

391
  __forceinline vfloat4 max(const vfloat4& a, const vfloat4& b) { return _mm_max_ps(a,b); }
392
  __forceinline vfloat4 max(const vfloat4& a, float          b) { return _mm_max_ps(a,vfloat4(b)); }
393
  __forceinline vfloat4 max(float          a, const vfloat4& b) { return _mm_max_ps(vfloat4(a),b); }
394

395
#if defined(__SSE4_1__) || defined(__aarch64__)
396

397
    __forceinline vfloat4 mini(const vfloat4& a, const vfloat4& b) {
398
      const vint4 ai = _mm_castps_si128(a);
399
      const vint4 bi = _mm_castps_si128(b);
400
      const vint4 ci = _mm_min_epi32(ai,bi);
401
      return _mm_castsi128_ps(ci);
402
    }
403

404
    __forceinline vfloat4 maxi(const vfloat4& a, const vfloat4& b) {
405
      const vint4 ai = _mm_castps_si128(a);
406
      const vint4 bi = _mm_castps_si128(b);
407
      const vint4 ci = _mm_max_epi32(ai,bi);
408
      return _mm_castsi128_ps(ci);
409
    }
410

411
    __forceinline vfloat4 minui(const vfloat4& a, const vfloat4& b) {
412
      const vint4 ai = _mm_castps_si128(a);
413
      const vint4 bi = _mm_castps_si128(b);
414
      const vint4 ci = _mm_min_epu32(ai,bi);
415
      return _mm_castsi128_ps(ci);
416
    }
417

418
    __forceinline vfloat4 maxui(const vfloat4& a, const vfloat4& b) {
419
      const vint4 ai = _mm_castps_si128(a);
420
      const vint4 bi = _mm_castps_si128(b);
421
      const vint4 ci = _mm_max_epu32(ai,bi);
422
      return _mm_castsi128_ps(ci);
423
    }
424
#else
425
    __forceinline vfloat4 mini(const vfloat4& a, const vfloat4& b) {
426
      return min(a,b);
427
    }
428

429
    __forceinline vfloat4 maxi(const vfloat4& a, const vfloat4& b) {
430
      return max(a,b);
431
    }
432
#endif
433

434
  ////////////////////////////////////////////////////////////////////////////////
435
  /// Ternary Operators
436
  ////////////////////////////////////////////////////////////////////////////////
437

438
#if defined(__AVX2__) || defined(__ARM_NEON)
439
  __forceinline vfloat4 madd (const vfloat4& a, const vfloat4& b, const vfloat4& c) { return _mm_fmadd_ps(a,b,c); }
440
  __forceinline vfloat4 msub (const vfloat4& a, const vfloat4& b, const vfloat4& c) { return _mm_fmsub_ps(a,b,c); }
441
  __forceinline vfloat4 nmadd(const vfloat4& a, const vfloat4& b, const vfloat4& c) { return _mm_fnmadd_ps(a,b,c); }
442
  __forceinline vfloat4 nmsub(const vfloat4& a, const vfloat4& b, const vfloat4& c) { return _mm_fnmsub_ps(a,b,c); }
443
#else
444
  __forceinline vfloat4 madd (const vfloat4& a, const vfloat4& b, const vfloat4& c) { return a*b+c; }
445
  __forceinline vfloat4 nmadd(const vfloat4& a, const vfloat4& b, const vfloat4& c) { return -a*b+c;}
446
  __forceinline vfloat4 nmsub(const vfloat4& a, const vfloat4& b, const vfloat4& c) { return -a*b-c; }
447
  __forceinline vfloat4 msub (const vfloat4& a, const vfloat4& b, const vfloat4& c) { return a*b-c; }
448

449
#endif
450

451
  ////////////////////////////////////////////////////////////////////////////////
452
  /// Assignment Operators
453
  ////////////////////////////////////////////////////////////////////////////////
454

455
  __forceinline vfloat4& operator +=(vfloat4& a, const vfloat4& b) { return a = a + b; }
456
  __forceinline vfloat4& operator +=(vfloat4& a, float          b) { return a = a + b; }
457

458
  __forceinline vfloat4& operator -=(vfloat4& a, const vfloat4& b) { return a = a - b; }
459
  __forceinline vfloat4& operator -=(vfloat4& a, float          b) { return a = a - b; }
460

461
  __forceinline vfloat4& operator *=(vfloat4& a, const vfloat4& b) { return a = a * b; }
462
  __forceinline vfloat4& operator *=(vfloat4& a, float          b) { return a = a * b; }
463

464
  __forceinline vfloat4& operator /=(vfloat4& a, const vfloat4& b) { return a = a / b; }
465
  __forceinline vfloat4& operator /=(vfloat4& a, float          b) { return a = a / b; }
466

467
  ////////////////////////////////////////////////////////////////////////////////
468
  /// Comparison Operators + Select
469
  ////////////////////////////////////////////////////////////////////////////////
470

471
#if defined(__AVX512VL__)
472
  __forceinline vboolf4 operator ==(const vfloat4& a, const vfloat4& b) { return _mm_cmp_ps_mask(a, b, _MM_CMPINT_EQ); }
473
  __forceinline vboolf4 operator !=(const vfloat4& a, const vfloat4& b) { return _mm_cmp_ps_mask(a, b, _MM_CMPINT_NE); }
474
  __forceinline vboolf4 operator < (const vfloat4& a, const vfloat4& b) { return _mm_cmp_ps_mask(a, b, _MM_CMPINT_LT); }
475
  __forceinline vboolf4 operator >=(const vfloat4& a, const vfloat4& b) { return _mm_cmp_ps_mask(a, b, _MM_CMPINT_GE); }
476
  __forceinline vboolf4 operator > (const vfloat4& a, const vfloat4& b) { return _mm_cmp_ps_mask(a, b, _MM_CMPINT_GT); }
477
  __forceinline vboolf4 operator <=(const vfloat4& a, const vfloat4& b) { return _mm_cmp_ps_mask(a, b, _MM_CMPINT_LE); }
478
#else
479
  __forceinline vboolf4 operator ==(const vfloat4& a, const vfloat4& b) { return _mm_cmpeq_ps (a, b); }
480
  __forceinline vboolf4 operator !=(const vfloat4& a, const vfloat4& b) { return _mm_cmpneq_ps(a, b); }
481
  __forceinline vboolf4 operator < (const vfloat4& a, const vfloat4& b) { return _mm_cmplt_ps (a, b); }
482
#if defined(__aarch64__)
483
  __forceinline vboolf4 operator >=(const vfloat4& a, const vfloat4& b) { return _mm_cmpge_ps (a, b); }
484
  __forceinline vboolf4 operator > (const vfloat4& a, const vfloat4& b) { return _mm_cmpgt_ps (a, b); }
485
#else
486
  __forceinline vboolf4 operator >=(const vfloat4& a, const vfloat4& b) { return _mm_cmpnlt_ps(a, b); }
487
  __forceinline vboolf4 operator > (const vfloat4& a, const vfloat4& b) { return _mm_cmpnle_ps(a, b); }
488
#endif
489
  __forceinline vboolf4 operator <=(const vfloat4& a, const vfloat4& b) { return _mm_cmple_ps (a, b); }
490
#endif
491

492
  __forceinline vboolf4 operator ==(const vfloat4& a, float          b) { return a == vfloat4(b); }
493
  __forceinline vboolf4 operator ==(float          a, const vfloat4& b) { return vfloat4(a) == b; }
494

495
  __forceinline vboolf4 operator !=(const vfloat4& a, float          b) { return a != vfloat4(b); }
496
  __forceinline vboolf4 operator !=(float          a, const vfloat4& b) { return vfloat4(a) != b; }
497

498
  __forceinline vboolf4 operator < (const vfloat4& a, float          b) { return a <  vfloat4(b); }
499
  __forceinline vboolf4 operator < (float          a, const vfloat4& b) { return vfloat4(a) <  b; }
500
  
501
  __forceinline vboolf4 operator >=(const vfloat4& a, float          b) { return a >= vfloat4(b); }
502
  __forceinline vboolf4 operator >=(float          a, const vfloat4& b) { return vfloat4(a) >= b; }
503

504
  __forceinline vboolf4 operator > (const vfloat4& a, float          b) { return a >  vfloat4(b); }
505
  __forceinline vboolf4 operator > (float          a, const vfloat4& b) { return vfloat4(a) >  b; }
506

507
  __forceinline vboolf4 operator <=(const vfloat4& a, float          b) { return a <= vfloat4(b); }
508
  __forceinline vboolf4 operator <=(float          a, const vfloat4& b) { return vfloat4(a) <= b; }
509

510
  __forceinline vboolf4 eq(const vfloat4& a, const vfloat4& b) { return a == b; }
511
  __forceinline vboolf4 ne(const vfloat4& a, const vfloat4& b) { return a != b; }
512
  __forceinline vboolf4 lt(const vfloat4& a, const vfloat4& b) { return a <  b; }
513
  __forceinline vboolf4 ge(const vfloat4& a, const vfloat4& b) { return a >= b; }
514
  __forceinline vboolf4 gt(const vfloat4& a, const vfloat4& b) { return a >  b; }
515
  __forceinline vboolf4 le(const vfloat4& a, const vfloat4& b) { return a <= b; }
516

517
#if defined(__AVX512VL__)
518
  __forceinline vboolf4 eq(const vboolf4& mask, const vfloat4& a, const vfloat4& b) { return _mm_mask_cmp_ps_mask(mask, a, b, _MM_CMPINT_EQ); }
519
  __forceinline vboolf4 ne(const vboolf4& mask, const vfloat4& a, const vfloat4& b) { return _mm_mask_cmp_ps_mask(mask, a, b, _MM_CMPINT_NE); }
520
  __forceinline vboolf4 lt(const vboolf4& mask, const vfloat4& a, const vfloat4& b) { return _mm_mask_cmp_ps_mask(mask, a, b, _MM_CMPINT_LT); }
521
  __forceinline vboolf4 ge(const vboolf4& mask, const vfloat4& a, const vfloat4& b) { return _mm_mask_cmp_ps_mask(mask, a, b, _MM_CMPINT_GE); }
522
  __forceinline vboolf4 gt(const vboolf4& mask, const vfloat4& a, const vfloat4& b) { return _mm_mask_cmp_ps_mask(mask, a, b, _MM_CMPINT_GT); }
523
  __forceinline vboolf4 le(const vboolf4& mask, const vfloat4& a, const vfloat4& b) { return _mm_mask_cmp_ps_mask(mask, a, b, _MM_CMPINT_LE); }
524
#else
525
  __forceinline vboolf4 eq(const vboolf4& mask, const vfloat4& a, const vfloat4& b) { return mask & (a == b); }
526
  __forceinline vboolf4 ne(const vboolf4& mask, const vfloat4& a, const vfloat4& b) { return mask & (a != b); }
527
  __forceinline vboolf4 lt(const vboolf4& mask, const vfloat4& a, const vfloat4& b) { return mask & (a <  b); }
528
  __forceinline vboolf4 ge(const vboolf4& mask, const vfloat4& a, const vfloat4& b) { return mask & (a >= b); }
529
  __forceinline vboolf4 gt(const vboolf4& mask, const vfloat4& a, const vfloat4& b) { return mask & (a >  b); }
530
  __forceinline vboolf4 le(const vboolf4& mask, const vfloat4& a, const vfloat4& b) { return mask & (a <= b); }
531
#endif
532

533
  template<int mask>
534
    __forceinline vfloat4 select(const vfloat4& t, const vfloat4& f)
535
  {
536
#if defined(__SSE4_1__) 
537
    return _mm_blend_ps(f, t, mask);
538
#else
539
    return select(vboolf4(mask), t, f);
540
#endif
541
  }
542

543
  __forceinline vfloat4 lerp(const vfloat4& a, const vfloat4& b, const vfloat4& t) {
544
    return madd(t,b-a,a);
545
  }
546
  
547
  __forceinline bool isvalid(const vfloat4& v) {
548
    return all((v > vfloat4(-FLT_LARGE)) & (v < vfloat4(+FLT_LARGE)));
549
  }
550

551
  __forceinline bool is_finite(const vfloat4& a) {
552
    return all((a >= vfloat4(-FLT_MAX)) & (a <= vfloat4(+FLT_MAX)));
553
  }
554

555
  __forceinline bool is_finite(const vboolf4& valid, const vfloat4& a) {
556
    return all(valid, (a >= vfloat4(-FLT_MAX)) & (a <= vfloat4(+FLT_MAX)));
557
  }
558
  
559
  ////////////////////////////////////////////////////////////////////////////////
560
  /// Rounding Functions
561
  ////////////////////////////////////////////////////////////////////////////////
562

563
#if defined(__aarch64__)
564
  __forceinline vfloat4 floor(const vfloat4& a) { return vrndmq_f32(a.v); } // towards -inf
565
  __forceinline vfloat4 ceil (const vfloat4& a) { return vrndpq_f32(a.v); } // toward +inf
566
  __forceinline vfloat4 trunc(const vfloat4& a) { return vrndq_f32(a.v); } // towards 0
567
  __forceinline vfloat4 round(const vfloat4& a) { return vrndnq_f32(a.v); } // to nearest, ties to even. NOTE(LTE): arm clang uses vrndnq, old gcc uses vrndqn?
568
#elif defined (__SSE4_1__)
569
  __forceinline vfloat4 floor(const vfloat4& a) { return _mm_round_ps(a, _MM_FROUND_TO_NEG_INF    ); }
570
  __forceinline vfloat4 ceil (const vfloat4& a) { return _mm_round_ps(a, _MM_FROUND_TO_POS_INF    ); }
571
  __forceinline vfloat4 trunc(const vfloat4& a) { return _mm_round_ps(a, _MM_FROUND_TO_ZERO       ); }
572
  __forceinline vfloat4 round(const vfloat4& a) { return _mm_round_ps(a, _MM_FROUND_TO_NEAREST_INT); }
573
#else
574
  __forceinline vfloat4 floor(const vfloat4& a) { return vfloat4(floorf(a[0]),floorf(a[1]),floorf(a[2]),floorf(a[3])); }
575
  __forceinline vfloat4 ceil (const vfloat4& a) { return vfloat4(ceilf (a[0]),ceilf (a[1]),ceilf (a[2]),ceilf (a[3])); }
576
  __forceinline vfloat4 trunc(const vfloat4& a) { return vfloat4(truncf(a[0]),truncf(a[1]),truncf(a[2]),truncf(a[3])); }
577
  __forceinline vfloat4 round(const vfloat4& a) { return vfloat4(roundf(a[0]),roundf(a[1]),roundf(a[2]),roundf(a[3])); }
578
#endif
579
  __forceinline vfloat4 frac(const vfloat4& a) { return a-floor(a); }
580

581
  __forceinline vint4 floori(const vfloat4& a) {
582
#if defined(__aarch64__)
583
    return vcvtq_s32_f32(floor(a));
584
#elif defined(__SSE4_1__)
585
    return vint4(floor(a));
586
#else
587
    return vint4(a-vfloat4(0.5f));
588
#endif
589
  }
590

591
  ////////////////////////////////////////////////////////////////////////////////
592
  /// Movement/Shifting/Shuffling Functions
593
  ////////////////////////////////////////////////////////////////////////////////
594

595
  __forceinline vfloat4 unpacklo(const vfloat4& a, const vfloat4& b) { return _mm_unpacklo_ps(a, b); }
596
  __forceinline vfloat4 unpackhi(const vfloat4& a, const vfloat4& b) { return _mm_unpackhi_ps(a, b); }
597

598
#if defined(__aarch64__)
599
      template<int i0, int i1, int i2, int i3>
600
      __forceinline vfloat4 shuffle(const vfloat4& v) {
601
          return vreinterpretq_f32_u8(vqtbl1q_u8( (uint8x16_t)v.v, _MN_SHUFFLE(i0, i1, i2, i3)));
602
      }
603
      template<int i0, int i1, int i2, int i3>
604
      __forceinline vfloat4 shuffle(const vfloat4& a, const vfloat4& b) {
605
          return vreinterpretq_f32_u8(vqtbl2q_u8( (uint8x16x2_t){(uint8x16_t)a.v, (uint8x16_t)b.v}, _MF_SHUFFLE(i0, i1, i2, i3)));
606
      }
607
#else
608
  template<int i0, int i1, int i2, int i3>
609
  __forceinline vfloat4 shuffle(const vfloat4& v) {
610
    return _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(v), _MM_SHUFFLE(i3, i2, i1, i0)));
611
  }
612

613
  template<int i0, int i1, int i2, int i3>
614
  __forceinline vfloat4 shuffle(const vfloat4& a, const vfloat4& b) {
615
    return _mm_shuffle_ps(a, b, _MM_SHUFFLE(i3, i2, i1, i0));
616
  }
617
#endif
618

619
#if defined(__SSE3__) && !defined(__aarch64__)
620
  template<> __forceinline vfloat4 shuffle<0, 0, 2, 2>(const vfloat4& v) { return _mm_moveldup_ps(v); }
621
  template<> __forceinline vfloat4 shuffle<1, 1, 3, 3>(const vfloat4& v) { return _mm_movehdup_ps(v); }
622
  template<> __forceinline vfloat4 shuffle<0, 1, 0, 1>(const vfloat4& v) { return _mm_castpd_ps(_mm_movedup_pd(_mm_castps_pd(v))); }
623
#endif
624

625
  template<int i>
626
  __forceinline vfloat4 shuffle(const vfloat4& v) {
627
    return shuffle<i,i,i,i>(v);
628
  }
629

630
#if defined(__aarch64__)
631
  template<int i> __forceinline float extract(const vfloat4& a) { return a[i]; }
632
#else
633
  template<int i> __forceinline float extract   (const vfloat4& a) { return _mm_cvtss_f32(shuffle<i>(a)); }
634
  template<>      __forceinline float extract<0>(const vfloat4& a) { return _mm_cvtss_f32(a); }
635
#endif
636

637
#if defined (__SSE4_1__) && !defined(__aarch64__)
638
  template<int dst, int src, int clr> __forceinline vfloat4 insert(const vfloat4& a, const vfloat4& b) { return _mm_insert_ps(a, b, (dst << 4) | (src << 6) | clr); }
639
  template<int dst, int src> __forceinline vfloat4 insert(const vfloat4& a, const vfloat4& b) { return insert<dst, src, 0>(a, b); }
640
  template<int dst> __forceinline vfloat4 insert(const vfloat4& a, const float b) { return insert<dst, 0>(a, _mm_set_ss(b)); }
641
#else
642
  template<int dst, int src> __forceinline vfloat4 insert(const vfloat4& a, const vfloat4& b) { vfloat4 c = a; c[dst&3] = b[src&3]; return c; }
643
  template<int dst>  __forceinline vfloat4 insert(const vfloat4& a, float b) { vfloat4 c = a; c[dst&3] = b; return c; }
644
#endif
645

646
  __forceinline float toScalar(const vfloat4& v) { return _mm_cvtss_f32(v); }
647

648
  __forceinline vfloat4 shift_right_1(const vfloat4& x) {
649
    return _mm_castsi128_ps(_mm_srli_si128(_mm_castps_si128(x), 4)); 
650
  }
651

652
#if defined (__AVX2__)
653
  __forceinline vfloat4 permute(const vfloat4 &a, const __m128i &index) {
654
    return _mm_permutevar_ps(a,index);
655
  }
656

657
  __forceinline vfloat4 broadcast1f(const void* a) { return _mm_broadcast_ss((float*)a); }
658

659
#endif
660

661
#if defined(__AVX512VL__)
662
  template<int i>
663
  __forceinline vfloat4 align_shift_right(const vfloat4& a, const vfloat4& b) {
664
    return _mm_castsi128_ps(_mm_alignr_epi32(_mm_castps_si128(a), _mm_castps_si128(b), i));
665
  }  
666
#endif
667

668

669
  ////////////////////////////////////////////////////////////////////////////////
670
  /// Sorting Network
671
  ////////////////////////////////////////////////////////////////////////////////
672

673
  __forceinline vfloat4 sort_ascending(const vfloat4& v)
674
  {
675
    const vfloat4 a0 = v;
676
    const vfloat4 b0 = shuffle<1,0,3,2>(a0);
677
    const vfloat4 c0 = min(a0,b0);
678
    const vfloat4 d0 = max(a0,b0);
679
    const vfloat4 a1 = select<0x5 /* 0b0101 */>(c0,d0);
680
    const vfloat4 b1 = shuffle<2,3,0,1>(a1);
681
    const vfloat4 c1 = min(a1,b1);
682
    const vfloat4 d1 = max(a1,b1);
683
    const vfloat4 a2 = select<0x3 /* 0b0011 */>(c1,d1);
684
    const vfloat4 b2 = shuffle<0,2,1,3>(a2);
685
    const vfloat4 c2 = min(a2,b2);
686
    const vfloat4 d2 = max(a2,b2);
687
    const vfloat4 a3 = select<0x2 /* 0b0010 */>(c2,d2);
688
    return a3;
689
  }
690

691
  __forceinline vfloat4 sort_descending(const vfloat4& v)
692
  {
693
    const vfloat4 a0 = v;
694
    const vfloat4 b0 = shuffle<1,0,3,2>(a0);
695
    const vfloat4 c0 = max(a0,b0);
696
    const vfloat4 d0 = min(a0,b0);
697
    const vfloat4 a1 = select<0x5 /* 0b0101 */>(c0,d0);
698
    const vfloat4 b1 = shuffle<2,3,0,1>(a1);
699
    const vfloat4 c1 = max(a1,b1);
700
    const vfloat4 d1 = min(a1,b1);
701
    const vfloat4 a2 = select<0x3 /* 0b0011 */>(c1,d1);
702
    const vfloat4 b2 = shuffle<0,2,1,3>(a2);
703
    const vfloat4 c2 = max(a2,b2);
704
    const vfloat4 d2 = min(a2,b2);
705
    const vfloat4 a3 = select<0x2 /* 0b0010 */>(c2,d2);
706
    return a3;
707
  }
708

709
  ////////////////////////////////////////////////////////////////////////////////
710
  /// Transpose
711
  ////////////////////////////////////////////////////////////////////////////////
712

713
  __forceinline void transpose(const vfloat4& r0, const vfloat4& r1, const vfloat4& r2, const vfloat4& r3, vfloat4& c0, vfloat4& c1, vfloat4& c2, vfloat4& c3)
714
  {
715
    vfloat4 l02 = unpacklo(r0,r2);
716
    vfloat4 h02 = unpackhi(r0,r2);
717
    vfloat4 l13 = unpacklo(r1,r3);
718
    vfloat4 h13 = unpackhi(r1,r3);
719
    c0 = unpacklo(l02,l13);
720
    c1 = unpackhi(l02,l13);
721
    c2 = unpacklo(h02,h13);
722
    c3 = unpackhi(h02,h13);
723
  }
724

725
  __forceinline void transpose(const vfloat4& r0, const vfloat4& r1, const vfloat4& r2, const vfloat4& r3, vfloat4& c0, vfloat4& c1, vfloat4& c2)
726
  {
727
    vfloat4 l02 = unpacklo(r0,r2);
728
    vfloat4 h02 = unpackhi(r0,r2);
729
    vfloat4 l13 = unpacklo(r1,r3);
730
    vfloat4 h13 = unpackhi(r1,r3);
731
    c0 = unpacklo(l02,l13);
732
    c1 = unpackhi(l02,l13);
733
    c2 = unpacklo(h02,h13);
734
  }
735

736
  ////////////////////////////////////////////////////////////////////////////////
737
  /// Reductions
738
  ////////////////////////////////////////////////////////////////////////////////
739
#if defined(__aarch64__)
740
  __forceinline vfloat4 vreduce_min(const vfloat4& v) { float h = vminvq_f32(v); return vdupq_n_f32(h); }
741
  __forceinline vfloat4 vreduce_max(const vfloat4& v) { float h = vmaxvq_f32(v); return vdupq_n_f32(h); }
742
  __forceinline vfloat4 vreduce_add(const vfloat4& v) { float h = vaddvq_f32(v); return vdupq_n_f32(h); }
743
#else
744
  __forceinline vfloat4 vreduce_min(const vfloat4& v) { vfloat4 h = min(shuffle<1,0,3,2>(v),v); return min(shuffle<2,3,0,1>(h),h); }
745
  __forceinline vfloat4 vreduce_max(const vfloat4& v) { vfloat4 h = max(shuffle<1,0,3,2>(v),v); return max(shuffle<2,3,0,1>(h),h); }
746
  __forceinline vfloat4 vreduce_add(const vfloat4& v) { vfloat4 h = shuffle<1,0,3,2>(v)   + v ; return shuffle<2,3,0,1>(h)   + h ; }
747
#endif
748

749
#if defined(__aarch64__)
750
  __forceinline float reduce_min(const vfloat4& v) { return vminvq_f32(v); }
751
  __forceinline float reduce_max(const vfloat4& v) { return vmaxvq_f32(v); }
752
  __forceinline float reduce_add(const vfloat4& v) { return vaddvq_f32(v); }
753
#else
754
  __forceinline float reduce_min(const vfloat4& v) { return _mm_cvtss_f32(vreduce_min(v)); }
755
  __forceinline float reduce_max(const vfloat4& v) { return _mm_cvtss_f32(vreduce_max(v)); }
756
  __forceinline float reduce_add(const vfloat4& v) { return _mm_cvtss_f32(vreduce_add(v)); }
757
#endif
758

759
  __forceinline size_t select_min(const vboolf4& valid, const vfloat4& v) 
760
  { 
761
    const vfloat4 a = select(valid,v,vfloat4(pos_inf)); 
762
    const vbool4 valid_min = valid & (a == vreduce_min(a));
763
    return bsf(movemask(any(valid_min) ? valid_min : valid)); 
764
  }
765
  __forceinline size_t select_max(const vboolf4& valid, const vfloat4& v) 
766
  { 
767
    const vfloat4 a = select(valid,v,vfloat4(neg_inf)); 
768
    const vbool4 valid_max = valid & (a == vreduce_max(a));
769
    return bsf(movemask(any(valid_max) ? valid_max : valid)); 
770
  }
771
  
772
  ////////////////////////////////////////////////////////////////////////////////
773
  /// Euclidean Space Operators
774
  ////////////////////////////////////////////////////////////////////////////////
775

776
  __forceinline float dot(const vfloat4& a, const vfloat4& b) {
777
    return reduce_add(a*b);
778
  }
779

780
  __forceinline vfloat4 cross(const vfloat4& a, const vfloat4& b)
781
  {
782
    const vfloat4 a0 = a;
783
    const vfloat4 b0 = shuffle<1,2,0,3>(b);
784
    const vfloat4 a1 = shuffle<1,2,0,3>(a);
785
    const vfloat4 b1 = b;
786
    return shuffle<1,2,0,3>(msub(a0,b0,a1*b1));
787
  }
788

789
  ////////////////////////////////////////////////////////////////////////////////
790
  /// Output Operators
791
  ////////////////////////////////////////////////////////////////////////////////
792

793
  __forceinline embree_ostream operator <<(embree_ostream cout, const vfloat4& a) {
794
    return cout << "<" << a[0] << ", " << a[1] << ", " << a[2] << ", " << a[3] << ">";
795
  }
796

797
}
798

799
#undef vboolf
800
#undef vboold
801
#undef vint
802
#undef vuint
803
#undef vllong
804
#undef vfloat
805
#undef vdouble
806

807
Product

Resources

Company
