CoCalc -- vboold4

GitHub Repository: godotengine/godot
Path: blob/master/thirdparty/embree/common/simd/vboold4_avx.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 AVX bool type for 64bit data types*/
17
  template<>
18
  struct vboold<4>
19
  {
20
    ALIGNED_STRUCT_(32);
21
    
22
    typedef vboold4 Bool;
23

24
    enum  { size = 4 };       // number of SIMD elements
25
    union {                   // data
26
      __m256d v;
27
      struct { __m128d vl,vh; };
28
      long long i[4];
29
    };
30

31
    ////////////////////////////////////////////////////////////////////////////////
32
    /// Constructors, Assignment & Cast Operators
33
    ////////////////////////////////////////////////////////////////////////////////
34

35
    __forceinline vboold() {}
36
    __forceinline vboold(const vboold4& a) { v = a.v; }
37
    __forceinline vboold4& operator =(const vboold4& a) { v = a.v; return *this; }
38

39
    __forceinline vboold(__m256d a) : v(a) {}
40
    __forceinline vboold(__m256i a) : v(_mm256_castsi256_pd(a)) {}
41

42
    __forceinline operator const __m256() const { return _mm256_castpd_ps(v); }
43
    __forceinline operator const __m256i() const { return _mm256_castpd_si256(v); }
44
    __forceinline operator const __m256d() const { return v; }
45

46
    __forceinline vboold(int a)
47
    {
48
      assert(a >= 0 && a <= 255);
49
#if defined (__AVX2__)
50
      const __m256i mask = _mm256_set_epi64x(0x8, 0x4, 0x2, 0x1);
51
      const __m256i b = _mm256_set1_epi64x(a);
52
      const __m256i c = _mm256_and_si256(b,mask);
53
      v = _mm256_castsi256_pd(_mm256_cmpeq_epi64(c,mask));
54
#else
55
      vl = mm_lookupmask_pd[a & 0x3];
56
      vh = mm_lookupmask_pd[a >> 2];
57
#endif
58
    }
59
    
60
    ////////////////////////////////////////////////////////////////////////////////
61
    /// Constants
62
    ////////////////////////////////////////////////////////////////////////////////
63

64
    __forceinline vboold(FalseTy) : v(_mm256_setzero_pd()) {}
65
#if !defined(__aarch64__)
66
    __forceinline vboold(TrueTy)  : v(_mm256_cmp_pd(_mm256_setzero_pd(), _mm256_setzero_pd(), _CMP_EQ_OQ)) {}
67
#else
68
    __forceinline vboold(TrueTy)  : v(_mm256_cmpeq_pd(_mm256_setzero_pd(), _mm256_setzero_pd())) {}
69
#endif
70

71
    ////////////////////////////////////////////////////////////////////////////////
72
    /// Array Access
73
    ////////////////////////////////////////////////////////////////////////////////
74

75
    __forceinline bool       operator [](size_t index) const { assert(index < 4); return (_mm256_movemask_pd(v) >> index) & 1; }
76
    __forceinline long long& operator [](size_t index)       { assert(index < 4); return i[index]; }
77
  };
78

79
  ////////////////////////////////////////////////////////////////////////////////
80
  /// Unary Operators
81
  ////////////////////////////////////////////////////////////////////////////////
82

83
  __forceinline vboold4 operator !(const vboold4& a) { return _mm256_xor_pd(a, vboold4(embree::True)); }
84

85
  ////////////////////////////////////////////////////////////////////////////////
86
  /// Binary Operators
87
  ////////////////////////////////////////////////////////////////////////////////
88

89
  __forceinline vboold4 operator &(const vboold4& a, const vboold4& b) { return _mm256_and_pd(a, b); }
90
  __forceinline vboold4 operator |(const vboold4& a, const vboold4& b) { return _mm256_or_pd (a, b); }
91
  __forceinline vboold4 operator ^(const vboold4& a, const vboold4& b) { return _mm256_xor_pd(a, b); }
92

93
  __forceinline vboold4 andn(const vboold4& a, const vboold4& b) { return _mm256_andnot_pd(b, a); }
94

95
  __forceinline vboold4& operator &=(vboold4& a, const vboold4& b) { return a = a & b; }
96
  __forceinline vboold4& operator |=(vboold4& a, const vboold4& b) { return a = a | b; }
97
  __forceinline vboold4& operator ^=(vboold4& a, const vboold4& b) { return a = a ^ b; }
98

99
  ////////////////////////////////////////////////////////////////////////////////
100
  /// Comparison Operators + Select
101
  ////////////////////////////////////////////////////////////////////////////////
102

103
  __forceinline vboold4 operator !=(const vboold4& a, const vboold4& b) { return _mm256_xor_pd(a, b); }
104
  __forceinline vboold4 operator ==(const vboold4& a, const vboold4& b) { return _mm256_xor_pd(_mm256_xor_pd(a,b),vboold4(embree::True)); }
105

106
  __forceinline vboold4 select(const vboold4& mask, const vboold4& t, const vboold4& f) {
107
    return _mm256_blendv_pd(f, t, mask); 
108
  }
109

110
  ////////////////////////////////////////////////////////////////////////////////
111
  /// Movement/Shifting/Shuffling Functions
112
  ////////////////////////////////////////////////////////////////////////////////
113

114
#if !defined(__aarch64__)
115
  __forceinline vboold4 unpacklo(const vboold4& a, const vboold4& b) { return _mm256_unpacklo_pd(a, b); }
116
  __forceinline vboold4 unpackhi(const vboold4& a, const vboold4& b) { return _mm256_unpackhi_pd(a, b); }
117
#endif
118

119
#if defined(__AVX2__)
120
  template<int i0, int i1, int i2, int i3>
121
  __forceinline vboold4 shuffle(const vboold4& v) {
122
    return _mm256_permute4x64_pd(v, _MM_SHUFFLE(i3, i2, i1, i0));
123
  }
124

125
  template<int i>
126
  __forceinline vboold4 shuffle(const vboold4& v) {
127
    return _mm256_permute4x64_pd(v, _MM_SHUFFLE(i, i, i, i));
128
  }
129
#endif
130

131

132
  ////////////////////////////////////////////////////////////////////////////////
133
  /// Reduction Operations
134
  ////////////////////////////////////////////////////////////////////////////////
135

136
  __forceinline bool reduce_and(const vboold4& a) { return _mm256_movemask_pd(a) == (unsigned int)0xf; }
137
  __forceinline bool reduce_or (const vboold4& a) { return !_mm256_testz_pd(a,a); }
138

139
  __forceinline bool all (const vboold4& a) { return _mm256_movemask_pd(a) == (unsigned int)0xf; }
140
  __forceinline bool any (const vboold4& a) { return !_mm256_testz_pd(a,a); }
141
  __forceinline bool none(const vboold4& a) { return _mm256_testz_pd(a,a) != 0; }
142

143
  __forceinline bool all (const vboold4& valid, const vboold4& b) { return all((!valid) | b); }
144
  __forceinline bool any (const vboold4& valid, const vboold4& b) { return any(valid & b); }
145
  __forceinline bool none(const vboold4& valid, const vboold4& b) { return none(valid & b); }
146

147
  __forceinline unsigned int movemask(const vboold4& a) { return _mm256_movemask_pd(a); }
148
  __forceinline size_t       popcnt  (const vboold4& a) { return popcnt((size_t)_mm256_movemask_pd(a)); }
149

150
  ////////////////////////////////////////////////////////////////////////////////
151
  /// Get/Set Functions
152
  ////////////////////////////////////////////////////////////////////////////////
153

154
  __forceinline bool get(const vboold4& a, size_t index) { return a[index]; }
155
  __forceinline void set  (vboold4& a, size_t index)     { a[index] = -1; }
156
  __forceinline void clear(vboold4& a, size_t index)     { a[index] =  0; }
157

158
  ////////////////////////////////////////////////////////////////////////////////
159
  /// Output Operators
160
  ////////////////////////////////////////////////////////////////////////////////
161

162
  __forceinline embree_ostream operator <<(embree_ostream cout, const vboold4& a) {
163
    return cout << "<" << a[0] << ", " << a[1] << ", " << a[2] << ", " << a[3] << ", "
164
                       << a[4] << ", " << a[5] << ", " << a[6] << ", " << a[7] << ">";
165
  }
166
}
167

168
#undef vboolf
169
#undef vboold
170
#undef vint
171
#undef vuint
172
#undef vllong
173
#undef vfloat
174
#undef vdouble
175

176
Product

Resources

Company
