Vector Optimized Library of Kernels 3.3.0
Architecture-tuned implementations of math kernels
Loading...
Searching...
No Matches
volk_32f_x2_subtract_32f.h
Go to the documentation of this file.
1/* -*- c++ -*- */
2/*
3 * Copyright 2012, 2014 Free Software Foundation, Inc.
4 *
5 * This file is part of VOLK
6 *
7 * SPDX-License-Identifier: LGPL-3.0-or-later
8 */
9
57
58#ifndef INCLUDED_volk_32f_x2_subtract_32f_a_H
59#define INCLUDED_volk_32f_x2_subtract_32f_a_H
60
61#include <inttypes.h>
62#include <stdio.h>
63
64
65#ifdef LV_HAVE_GENERIC
66
67static inline void volk_32f_x2_subtract_32f_generic(float* cVector,
68 const float* aVector,
69 const float* bVector,
70 unsigned int num_points)
71{
72 for (unsigned int number = 0; number < num_points; number++) {
73 *cVector++ = (*aVector++) - (*bVector++);
74 }
75}
76#endif /* LV_HAVE_GENERIC */
77
78
79#ifdef LV_HAVE_AVX512F
80#include <immintrin.h>
81
82static inline void volk_32f_x2_subtract_32f_a_avx512f(float* cVector,
83 const float* aVector,
84 const float* bVector,
85 unsigned int num_points)
86{
87 const unsigned int sixteenthPoints = num_points / 16;
88
89 for (unsigned int number = 0; number < sixteenthPoints; number++) {
90 __m512 aVal = _mm512_load_ps(aVector);
91 __m512 bVal = _mm512_load_ps(bVector);
92
93 __m512 cVal = _mm512_sub_ps(aVal, bVal);
94
95 _mm512_store_ps(cVector, cVal); // Store the results back into the C container
96
97 aVector += 16;
98 bVector += 16;
99 cVector += 16;
100 }
101
102 volk_32f_x2_subtract_32f_generic(
103 cVector, aVector, bVector, num_points - sixteenthPoints * 16);
104}
105#endif /* LV_HAVE_AVX512F */
106
107#ifdef LV_HAVE_AVX
108#include <immintrin.h>
109
110static inline void volk_32f_x2_subtract_32f_a_avx(float* cVector,
111 const float* aVector,
112 const float* bVector,
113 unsigned int num_points)
114{
115 const unsigned int eighthPoints = num_points / 8;
116
117 for (unsigned int number = 0; number < eighthPoints; number++) {
118 __m256 aVal = _mm256_load_ps(aVector);
119 __m256 bVal = _mm256_load_ps(bVector);
120
121 __m256 cVal = _mm256_sub_ps(aVal, bVal);
122
123 _mm256_store_ps(cVector, cVal); // Store the results back into the C container
124
125 aVector += 8;
126 bVector += 8;
127 cVector += 8;
128 }
129
130 volk_32f_x2_subtract_32f_generic(
131 cVector, aVector, bVector, num_points - eighthPoints * 8);
132}
133#endif /* LV_HAVE_AVX */
134
135#ifdef LV_HAVE_SSE
136#include <xmmintrin.h>
137
138static inline void volk_32f_x2_subtract_32f_a_sse(float* cVector,
139 const float* aVector,
140 const float* bVector,
141 unsigned int num_points)
142{
143 const unsigned int quarterPoints = num_points / 4;
144
145 for (unsigned int number = 0; number < quarterPoints; number++) {
146 __m128 aVal = _mm_load_ps(aVector);
147 __m128 bVal = _mm_load_ps(bVector);
148
149 __m128 cVal = _mm_sub_ps(aVal, bVal);
150
151 _mm_store_ps(cVector, cVal); // Store the results back into the C container
152
153 aVector += 4;
154 bVector += 4;
155 cVector += 4;
156 }
157
158 volk_32f_x2_subtract_32f_generic(
159 cVector, aVector, bVector, num_points - quarterPoints * 4);
160}
161#endif /* LV_HAVE_SSE */
162
163
164#ifdef LV_HAVE_NEON
165#include <arm_neon.h>
166
167static inline void volk_32f_x2_subtract_32f_neon(float* cVector,
168 const float* aVector,
169 const float* bVector,
170 unsigned int num_points)
171{
172 const unsigned int quarterPoints = num_points / 4;
173
174 for (unsigned int number = 0; number < quarterPoints; number++) {
175 float32x4_t a_vec = vld1q_f32(aVector);
176 float32x4_t b_vec = vld1q_f32(bVector);
177
178 float32x4_t c_vec = vsubq_f32(a_vec, b_vec);
179
180 vst1q_f32(cVector, c_vec);
181
182 aVector += 4;
183 bVector += 4;
184 cVector += 4;
185 }
186
187 volk_32f_x2_subtract_32f_generic(
188 cVector, aVector, bVector, num_points - quarterPoints * 4);
189}
190#endif /* LV_HAVE_NEON */
191
192
193#ifdef LV_HAVE_NEONV8
194#include <arm_neon.h>
195
196static inline void volk_32f_x2_subtract_32f_neonv8(float* cVector,
197 const float* aVector,
198 const float* bVector,
199 unsigned int num_points)
200{
201 unsigned int n = num_points;
202 float* c = cVector;
203 const float* a = aVector;
204 const float* b = bVector;
205
206 /* Process 8 floats per iteration (2x unroll) */
207 while (n >= 8) {
208 float32x4_t a0 = vld1q_f32(a);
209 float32x4_t a1 = vld1q_f32(a + 4);
210 float32x4_t b0 = vld1q_f32(b);
211 float32x4_t b1 = vld1q_f32(b + 4);
212 __VOLK_PREFETCH(a + 16);
213 __VOLK_PREFETCH(b + 16);
214
215 vst1q_f32(c, vsubq_f32(a0, b0));
216 vst1q_f32(c + 4, vsubq_f32(a1, b1));
217
218 a += 8;
219 b += 8;
220 c += 8;
221 n -= 8;
222 }
223
224 /* Process remaining 4 floats */
225 if (n >= 4) {
226 vst1q_f32(c, vsubq_f32(vld1q_f32(a), vld1q_f32(b)));
227 a += 4;
228 b += 4;
229 c += 4;
230 n -= 4;
231 }
232
233 /* Scalar tail */
234 while (n > 0) {
235 *c++ = *a++ - *b++;
236 n--;
237 }
238}
239
240#endif /* LV_HAVE_NEONV8 */
241
242
243#ifdef LV_HAVE_ORC
244extern void volk_32f_x2_subtract_32f_a_orc_impl(float* cVector,
245 const float* aVector,
246 const float* bVector,
247 int num_points);
248
249static inline void volk_32f_x2_subtract_32f_u_orc(float* cVector,
250 const float* aVector,
251 const float* bVector,
252 unsigned int num_points)
253{
254 volk_32f_x2_subtract_32f_a_orc_impl(cVector, aVector, bVector, num_points);
255}
256#endif /* LV_HAVE_ORC */
257
258
259#endif /* INCLUDED_volk_32f_x2_subtract_32f_a_H */
260
261
262#ifndef INCLUDED_volk_32f_x2_subtract_32f_u_H
263#define INCLUDED_volk_32f_x2_subtract_32f_u_H
264
265#include <inttypes.h>
266#include <stdio.h>
267
268#ifdef LV_HAVE_AVX512F
269#include <immintrin.h>
270
271static inline void volk_32f_x2_subtract_32f_u_avx512f(float* cVector,
272 const float* aVector,
273 const float* bVector,
274 unsigned int num_points)
275{
276 const unsigned int sixteenthPoints = num_points / 16;
277
278 for (unsigned int number = 0; number < sixteenthPoints; number++) {
279 __m512 aVal = _mm512_loadu_ps(aVector);
280 __m512 bVal = _mm512_loadu_ps(bVector);
281
282 __m512 cVal = _mm512_sub_ps(aVal, bVal);
283
284 _mm512_storeu_ps(cVector, cVal); // Store the results back into the C container
285
286 aVector += 16;
287 bVector += 16;
288 cVector += 16;
289 }
290
291 volk_32f_x2_subtract_32f_generic(
292 cVector, aVector, bVector, num_points - sixteenthPoints * 16);
293}
294#endif /* LV_HAVE_AVX512F */
295
296
297#ifdef LV_HAVE_AVX
298#include <immintrin.h>
299
300static inline void volk_32f_x2_subtract_32f_u_avx(float* cVector,
301 const float* aVector,
302 const float* bVector,
303 unsigned int num_points)
304{
305 const unsigned int eighthPoints = num_points / 8;
306
307 for (unsigned int number = 0; number < eighthPoints; number++) {
308 __m256 aVal = _mm256_loadu_ps(aVector);
309 __m256 bVal = _mm256_loadu_ps(bVector);
310
311 __m256 cVal = _mm256_sub_ps(aVal, bVal);
312
313 _mm256_storeu_ps(cVector, cVal); // Store the results back into the C container
314
315 aVector += 8;
316 bVector += 8;
317 cVector += 8;
318 }
319
320 volk_32f_x2_subtract_32f_generic(
321 cVector, aVector, bVector, num_points - eighthPoints * 8);
322}
323#endif /* LV_HAVE_AVX */
324
325#ifdef LV_HAVE_RVV
326#include <riscv_vector.h>
327
328static inline void volk_32f_x2_subtract_32f_rvv(float* cVector,
329 const float* aVector,
330 const float* bVector,
331 unsigned int num_points)
332{
333 size_t n = num_points;
334 for (size_t vl; n > 0; n -= vl, aVector += vl, bVector += vl, cVector += vl) {
335 vl = __riscv_vsetvl_e32m8(n);
336 vfloat32m8_t va = __riscv_vle32_v_f32m8(aVector, vl);
337 vfloat32m8_t vb = __riscv_vle32_v_f32m8(bVector, vl);
338 __riscv_vse32(cVector, __riscv_vfsub(va, vb, vl), vl);
339 }
340}
341#endif /*LV_HAVE_RVV*/
342
343#endif /* INCLUDED_volk_32f_x2_subtract_32f_u_H */