Version
menu_open
Wwise SDK 2023.1.4
AkSimdAvx2.h
Go to the documentation of this file.
1 /*******************************************************************************
2 The content of this file includes portions of the AUDIOKINETIC Wwise Technology
3 released in source code form as part of the SDK installer package.
4 
5 Commercial License Usage
6 
7 Licensees holding valid commercial licenses to the AUDIOKINETIC Wwise Technology
8 may use this file in accordance with the end user license agreement provided
9 with the software or, alternatively, in accordance with the terms contained in a
10 written agreement between you and Audiokinetic Inc.
11 
12 Apache License Usage
13 
14 Alternatively, this file may be used under the Apache License, Version 2.0 (the
15 "Apache License"); you may not use this file except in compliance with the
16 Apache License. You may obtain a copy of the Apache License at
17 http://www.apache.org/licenses/LICENSE-2.0.
18 
19 Unless required by applicable law or agreed to in writing, software distributed
20 under the Apache License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES
21 OR CONDITIONS OF ANY KIND, either express or implied. See the Apache License for
22 the specific language governing permissions and limitations under the License.
23 
24  Copyright (c) 2024 Audiokinetic Inc.
25 *******************************************************************************/
26 
27 // AkSimdAvx2.h
28 
29 /// \file
30 /// AKSIMD - AVX2 implementation
31 
32 #ifndef _AK_SIMD_AVX2_H_
33 #define _AK_SIMD_AVX2_H_
34 
37 
38 #if !defined(__AVX2__)
39 #error "Inclusion of AkSimdAvx2.h requires AVX2 instruction sets to be defined on platform"
40 #endif
41 
43 #include <string.h>
44 
45 ////////////////////////////////////////////////////////////////////////
46 /// @name AKSIMD arithmetic
47 //@{
48 
49 /// Cross-platform SIMD multiplication of 8 complex data elements with interleaved real and imaginary parts,
50 /// and taking advantage of fused-multiply-add instructions
51 static AkForceInline AKSIMD_V8F32 AKSIMD_COMPLEXMUL_AVX2(const AKSIMD_V8F32 cIn1, const AKSIMD_V8F32 cIn2)
52 {
53  __m256 real1Ext = _mm256_moveldup_ps(cIn1); // reals extended (a3, a3, a2, a2, a1, a1, a0, a0)
54  __m256 in2Shuf = _mm256_shuffle_ps(cIn2, cIn2, 0xB1); // shuf multiplicand (c3, d3, c2, d2, c1, d1, c0, d0)
55  __m256 imag1Ext = _mm256_movehdup_ps(cIn1); // multiplier imag (b3, b3, b2, b2, b1, b1, b0, b0)
56  __m256 temp = _mm256_mul_ps(imag1Ext, in2Shuf); // temp (b3c3, b3d3, b2c2, b2d2, b1c1, b1d1, b0c0, b0d0)
57  __m256 out = _mm256_fmaddsub_ps(real1Ext, cIn2, temp); // final (a3d3+b3c3, a3c3-b3d3, a2d2+b2c2, a2c2-b2d2, a1d1+b1c1, a1c1-b1d1, a0d0+b0c0, a0c0-b0d0)
58  return out;
59 }
60 
61 /// Vector multiply-add-sub operation.
62 #define AKSIMD_MADDSUB_V8F32( __a__, __b__, __c__ ) _mm256_fmaddsub_ps( (__a__), (__b__), (__c__) )
63 #define AKSIMD_MSUBADD_V8F32( __a__, __b__, __c__ ) _mm256_fmsubadd_ps( (__a__), (__b__), (__c__) )
64 
65 /// Vector multiply-add operation.
66 #define AKSIMD_MADD_V8F32( __a__, __b__, __c__ ) _mm256_fmadd_ps( (__a__), (__b__) , (__c__) )
67 #define AKSIMD_MSUB_V8F32( __a__, __b__, __c__ ) _mm256_fmsub_ps( (__a__), (__b__) , (__c__) )
68 
69 //@}
70 ////////////////////////////////////////////////////////////////////////
71 
72 ////////////////////////////////////////////////////////////////////////
73 /// @name AKSIMD shuffling
74 //@{
75 
76 /// For each 8b value in a, move it to the designated location in each 128b lane specified by the
77 /// corresponding control byte in b (or, if the control byte is >=16, set the dest to zero) (see _mm_shuffle_epi8)
78 #define AKSIMD_SHUFFLEB_V8I32(a, b) _mm256_shuffle_epi8(a, b)
79 
80 /// For each 16b integer, select one of the values from a and b using the provided control mask - if the
81 /// nth bit is false, the nth value from a will be selected; if true, the value from b will be selected.
82 /// (the mask applies to each 128b lane identically)
83 #define AKSIMD_BLEND_V16I16(a, b, i) _mm256_blend_epi16(a, b, i)
84 
85 #define AKSIMD_INSERT_V2I128( a, m128, idx) _mm256_inserti128_si256(a, m128, idx)
86 
87 /// For each 128b lane, select one of the four input 128b lanes across a and b,
88 /// based on the mask i. AKSIMD_SHUFFLE can still be directly used as a control
89 #define AKSIMD_PERMUTE_2X128_V8I32( a, b, i ) _mm256_permute2x128_si256(a, b, i)
90 
91 /// Selects the lower of each of the 128b lanes in a and b to be the result ( B A ), ( D C ) -> ( C A )
92 #define AKSIMD_DEINTERLEAVELANES_LO_V8I32( a, b ) AKSIMD_PERMUTE_2X128_V8I32(a, b, AKSIMD_PERMUTE128(2, 0))
93 
94 /// Selects the higher of each of the 128b lanes in a and b to be the result ( B A ), ( D C) -> ( D B )
95 #define AKSIMD_DEINTERLEAVELANES_HI_V8I32( a, b ) AKSIMD_PERMUTE_2X128_V8I32(a, b, AKSIMD_PERMUTE128(3, 1))
96 
97 /// Shuffle 64b elements across the 128b lanes of a, based on the mask i.
98 /// AKSIMD_SHUFFLE can still be directly used as a control
99 #define AKSIMD_PERMUTE_4X64_V8F32( a, i ) _mm256_castpd_ps(_mm256_permute4x64_pd(_mm256_castps_pd(a), i))
100 
101 //@}
102 ////////////////////////////////////////////////////////////////////////
103 
104 ////////////////////////////////////////////////////////////////////////
105 /// @name AKSIMD conversion
106 //@{
107 
108 /// Converts the eight signed 16b integer values of a to signed 32-bit integer values
109 #define AKSIMD_CONVERT_V8I16_TO_V8I32( __vec__ ) _mm256_cvtepi16_epi32( (__vec__) )
110 
111 //@}
112 ////////////////////////////////////////////////////////////////////////
113 
114 ////////////////////////////////////////////////////////////////////////
115 /// @name AKSIMD integer arithmetic
116 //@{
117 
118 /// Adds the eight integer values of a and b
119 #define AKSIMD_ADD_V8I32( a, b ) _mm256_add_epi32( a, b )
120 
121 #define AKSIMD_CMPLT_V8I32( a, b ) _mm256_cmpgt_epi32( b, a )
122 #define AKSIMD_CMPGT_V8I32( a, b ) _mm256_cmpgt_epi32( a, b )
123 #define AKSIMD_OR_V8I32( a, b ) _mm256_or_si256(a,b)
124 #define AKSIMD_XOR_V8I32( a, b ) _mm256_xor_si256(a,b)
125 #define AKSIMD_SUB_V8I32( a, b ) _mm256_sub_epi32(a,b)
126 
127 /// Computes the bitwise AND of the 256-bit value in a and the
128 /// 256-bit value in b (see _mm_and_si128)
129 #define AKSIMD_AND_V8I32( __a__, __b__ ) _mm256_and_si256( (__a__), (__b__) )
130 
131 /// Multiplies each 32-bit int value of a by b and returns the lower 32b of the result (no overflow or clamp)
132 #define AKSIMD_MULLO_V8I32( a , b) _mm256_mullo_epi32(a, b)
133 
134 /// Multiplies the low 16bits of a by b and stores it in V8I32 (no overflow)
135 #define AKSIMD_MULLO16_V8I32( a , b) _mm256_mullo_epi16(a, b)
136 
137 /// Subtracts each 16b integer of a by b
138 #define AKSIMD_SUB_V16I16( a, b ) _mm256_sub_epi16( a, b )
139 
140 /// Compares the 16 signed 16-bit integers in a and the 16 signed
141 /// 16-bit integers in b for greater than (see _mm_cmpgt_epi16)
142 #define AKSIMD_CMPGT_V16I16( __a__, __b__ ) _mm256_cmpgt_epi16( (__a__), (__b__) )
143 //@}
144 ////////////////////////////////////////////////////////////////////////
145 
146 ////////////////////////////////////////////////////////////////////////
147 /// @name AKSIMD packing / unpacking
148 //@{
149 
150 /// Interleaves the lower 4 signed or unsigned 16-bit integers in each lane of a
151 /// with the lower 4 signed or unsigned 16-bit integers in each lane of b
152 /// (see _mm_unpacklo_epi16)
153 #define AKSIMD_UNPACKLO_VECTOR16I16( a, b ) _mm256_unpacklo_epi16( a, b )
154 
155 /// Interleaves the upper 8 signed or unsigned 16-bit integers in each lane of a
156 /// with the upper 8 signed or unsigned 16-bit integers in each lane of b
157 /// (see _mm_unpackhi_epi16)
158 #define AKSIMD_UNPACKHI_VECTOR16I16( a, b ) _mm256_unpackhi_epi16( a, b )
159 
160 /// Packs the 8 signed 32-bit integers from a and b into 16 signed 16-bit
161 /// integers and saturates (see _mm_packs_epi32)
162 #define AKSIMD_PACKS_V8I32( a, b ) _mm256_packs_epi32( a, b )
163 
164 //@}
165 ////////////////////////////////////////////////////////////////////////
166 
167 ////////////////////////////////////////////////////////////////////////
168 /// @name AKSIMD shifting
169 //@{
170 
171 /// Shifts the 8 signed or unsigned 32-bit integers in a left by
172 /// in_shiftBy bits while shifting in zeros (see _mm_slli_epi32)
173 #define AKSIMD_SHIFTLEFT_V8I32( __vec__, __shiftBy__ ) \
174  _mm256_slli_epi32( (__vec__), (__shiftBy__) )
175 
176 /// Shifts the 8 signed or unsigned 32-bit integers in __vec__ left-wards by
177 /// SIXTEEN bits while shifting in zeros (see _mm_shuffle_epi8)
178 #define AKSIMD_SHIFTLEFT16_V8I32( __vec__ ) \
179  _mm256_shuffle_epi8( (__vec__), _mm256_set_epi8( \
180  0xd, 0xc, -1, -1, \
181  0x9, 0x8, -1, -1, \
182  0x5, 0x4, -1, -1, \
183  0x1, 0x0, -1, -1, \
184  0xd, 0xc, -1, -1, \
185  0x9, 0x8, -1, -1, \
186  0x5, 0x4, -1, -1, \
187  0x1, 0x0, -1, -1) )
188 
189 /// Shifts the 8 signed 32-bit integers in a right by in_shiftBy
190 /// bits while shifting in zeroes (see _mm_srli_epi32)
191 #define AKSIMD_SHIFTRIGHT_V8I32( __vec__, __shiftBy__ ) \
192  _mm256_srli_epi32( (__vec__), (__shiftBy__) )
193 
194 /// Shifts the 8 signed 32-bit integers in a right by in_shiftBy
195 /// bits while shifting in the sign bit (see _mm_srai_epi32)
196 #define AKSIMD_SHIFTRIGHTARITH_V8I32( __vec__, __shiftBy__ ) \
197  _mm256_srai_epi32( (__vec__), (__shiftBy__) )
198 
199 //@}
200 ////////////////////////////////////////////////////////////////////////
201 
202 ////////////////////////////////////////////////////////////////////////
203 /// @name AKSIMD gather
204 //@{
205 
206 /// To use these, provide a base_ptr, and an expression that calculates an
207 /// array index for the provided base_ptr. The expression can be a lambda,
208 /// such as follows:
209 /// AKSIMD_V8I32 viData = AKSIMD_GATHER_EPI32(src, [uIndex, uStep](int i)
210 /// { return (uIndex + uStep * i); });
211 /// This tends to perform better than a native VGATHER on most CPUs
212 
213 template <typename T, typename Function>
214 inline AKSIMD_V8I32 AKSIMD_GATHER_EPI32(const T* __restrict base_ptr, Function expr)
215 {
216  __m256i vals = _mm256_setzero_si256();
217  __m128i valsTemp[2] = { _mm_setzero_si128(),_mm_setzero_si128() };
218 #define _GATHER_SIM_FETCH(_x) \
219  {\
220  AkInt32 val;\
221  memcpy(&val, (base_ptr + expr(_x)), sizeof(val)); \
222  valsTemp[_x/4] = _mm_insert_epi32(valsTemp[_x/4], val, _x%4);\
223  }
224 
233 #undef _GATHER_SIM_FETCH
234  vals = _mm256_setr_m128i(valsTemp[0], valsTemp[1]);
235  return vals;
236 }
237 
238 template <typename T, typename Function>
239 inline AKSIMD_V8I32 AKSIMD_GATHER_EPI64(const T* base_ptr, Function expr)
240 {
241  __m256i vals = _mm256_setzero_si256();
242  __m128i valsTemp[2] = { _mm_setzero_si128(),_mm_setzero_si128() };
243 #define _GATHER_SIM_FETCH(_x) \
244  {\
245  AkInt64 val; \
246  memcpy(&val, (base_ptr + expr(_x)), sizeof(val)); \
247  valsTemp[_x/2] = _mm_insert_epi64(valsTemp[_x/2], val, _x%2);\
248  }
249 
254 #undef _GATHER_SIM_FETCH
255  vals = _mm256_setr_m128i(valsTemp[0], valsTemp[1]);
256  return vals;
257 }
258 
259 template <typename T, typename Function>
260 inline AKSIMD_V8F32 AKSIMD_GATHER_PS(const T* base_ptr, Function expr)
261 {
262  return _mm256_castsi256_ps(AKSIMD_GATHER_EPI32(base_ptr, expr));
263 }
264 
265 template <typename T, typename Function>
266 inline AKSIMD_V4F64 AKSIMD_GATHER_PD(const T* base_ptr, Function expr)
267 {
268  return _mm256_castsi256_pd(AKSIMD_GATHER_EPI64(base_ptr, expr));
269 }
270 
271 //@}
272 ////////////////////////////////////////////////////////////////////////
273 
274 
275 #endif //_AK_SIMD_AVX2_H_
static AkForceInline AKSIMD_V8F32 AKSIMD_COMPLEXMUL_AVX2(const AKSIMD_V8F32 cIn1, const AKSIMD_V8F32 cIn2)
Definition: AkSimdAvx2.h:51
AKSIMD_V8F32 AKSIMD_GATHER_PS(const T *base_ptr, Function expr)
Definition: AkSimdAvx2.h:260
#define _GATHER_SIM_FETCH(_x)
AKSIMD_V4F64 AKSIMD_GATHER_PD(const T *base_ptr, Function expr)
Definition: AkSimdAvx2.h:266
AKSIMD_V8I32 AKSIMD_GATHER_EPI32(const T *__restrict base_ptr, Function expr)
Definition: AkSimdAvx2.h:214
AKSIMD_V8I32 AKSIMD_GATHER_EPI64(const T *base_ptr, Function expr)
Definition: AkSimdAvx2.h:239
#define AkForceInline
Definition: AkTypes.h:63

Was this page helpful?

Need Support?

Questions? Problems? Need more info? Contact us, and we can help!

Visit our Support page

Tell us about your project. We're here to help.

Register your project and we'll help you get started with no strings attached!

Get started with Wwise