mirrors/gnss-sdr
1
0
Fork 0
mirror of https://github.com/gnss-sdr/gnss-sdr synced 2025-11-19 00:25:17 +00:00
Code Issues Releases Wiki Activity

Fix various linting errors, use clang-format-19

Browse Source 
Fix various linting errors, both for cpplint and
then clang-format. For the latter, used
clang-format-19 to quickly fix it all.

Signed-off-by: Marcus Alagar <mvala079@gmail.com>
This commit is contained in:
Marcus Alagar
2025-09-13 15:33:14 -07:00
parent 2e84e5bddb
commit 040262f906
27 changed files with 170 additions and 177 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_16i_rotator_dot_prod_16ic_xn.h
View File

@@ -791,24 +791,22 @@ static inline void volk_gnsssdr_16ic_16i_rotator_dot_prod_16ic_xn_rvv(lv_16sc_t*
size_t ROTATOR_RELOAD = 256; size_t ROTATOR_RELOAD = 256;
// Initialize reference pointers of compatible type that will not be stripmined // Initialize reference pointers of compatible type that will not be stripmined
float* phasePtr = (float*) phase; float* phasePtr = (float*)phase;
// Initialize pointers of compatible type to track progress as stripmine // Initialize pointers of compatible type to track progress as stripmine
short* outPtr = (short*) result; short* outPtr = (short*)result;
const short* comPtr = (const short*) in_common; const short* comPtr = (const short*)in_common;
const short** inPtrBuf = (const short**) volk_gnsssdr_malloc( const short** inPtrBuf = (const short**)volk_gnsssdr_malloc(num_a_vectors * sizeof(*in_a), volk_gnsssdr_get_alignment());
num_a_vectors * sizeof(*in_a), volk_gnsssdr_get_alignment()
);
for (int n_vec = 0; n_vec < num_a_vectors; n_vec++) for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
{ {
// Initialize `out` to zero // Initialize `out` to zero
result[n_vec] = lv_cmake(0, 0); result[n_vec] = lv_cmake(0, 0);
// Create copies in case pointers within `in_a` are not meant to be modified // Create copies in case pointers within `in_a` are not meant to be modified
// (in which case function signature should be `const short* const* in_a`) // (in which case function signature should be `const short* const* in_a`)
inPtrBuf[n_vec] = in_a[n_vec]; inPtrBuf[n_vec] = in_a[n_vec];
} }
for (int _ = 0; _ < num_points / ROTATOR_RELOAD; _++) for (int _ = 0; _ < num_points / ROTATOR_RELOAD; _++)
{ {
@@ -882,8 +880,8 @@ static inline void volk_gnsssdr_16ic_16i_rotator_dot_prod_16ic_xn_rvv(lv_16sc_t*
vint16m2_t outImagVal = __riscv_vmul_vv_i16m2(inVal, comProdImagVal, vl); vint16m2_t outImagVal = __riscv_vmul_vv_i16m2(inVal, comProdImagVal, vl);
// Load accumulator // Load accumulator
vint32m1_t accRealVal = __riscv_vmv_s_x_i32m1((int) outPtr[2 * n_vec], 1); vint32m1_t accRealVal = __riscv_vmv_s_x_i32m1((int)outPtr[2 * n_vec], 1);
vint32m1_t accImagVal = __riscv_vmv_s_x_i32m1((int) outPtr[2 * n_vec + 1], 1); vint32m1_t accImagVal = __riscv_vmv_s_x_i32m1((int)outPtr[2 * n_vec + 1], 1);
// acc[0] = sum( acc[0], out[0..vl) ) // acc[0] = sum( acc[0], out[0..vl) )
accRealVal = __riscv_vwredsum_vs_i16m2_i32m1(outRealVal, accRealVal, vl); accRealVal = __riscv_vwredsum_vs_i16m2_i32m1(outRealVal, accRealVal, vl);
@@ -898,8 +896,8 @@ static inline void volk_gnsssdr_16ic_16i_rotator_dot_prod_16ic_xn_rvv(lv_16sc_t*
accImagVal = __riscv_vmax_vx_i32m1(accImagVal, -32768, 1); accImagVal = __riscv_vmax_vx_i32m1(accImagVal, -32768, 1);
// Store acc[0] // Store acc[0]
outPtr[2 * n_vec] = (short) __riscv_vmv_x_s_i32m1_i32(accRealVal); outPtr[2 * n_vec] = (short)__riscv_vmv_x_s_i32m1_i32(accRealVal);
outPtr[2 * n_vec + 1] = (short) __riscv_vmv_x_s_i32m1_i32(accImagVal); outPtr[2 * n_vec + 1] = (short)__riscv_vmv_x_s_i32m1_i32(accImagVal);
// Increment this pointer // Increment this pointer
inPtrBuf[n_vec] += vl; inPtrBuf[n_vec] += vl;
@@ -918,7 +916,7 @@ static inline void volk_gnsssdr_16ic_16i_rotator_dot_prod_16ic_xn_rvv(lv_16sc_t*
// elements left and increment the pointers // elements left and increment the pointers
// by the number of elements processed // by the number of elements processed
} }
// Regenerate phase // Regenerate phase
#ifdef __cplusplus #ifdef __cplusplus
(*phase) /= std::abs((*phase)); (*phase) /= std::abs((*phase));
#else #else
@@ -996,8 +994,8 @@ static inline void volk_gnsssdr_16ic_16i_rotator_dot_prod_16ic_xn_rvv(lv_16sc_t*
vint16m2_t outImagVal = __riscv_vmul_vv_i16m2(inVal, comProdImagVal, vl); vint16m2_t outImagVal = __riscv_vmul_vv_i16m2(inVal, comProdImagVal, vl);
// Load accumulator // Load accumulator
vint32m1_t accRealVal = __riscv_vmv_s_x_i32m1((int) outPtr[2 * n_vec], 1); vint32m1_t accRealVal = __riscv_vmv_s_x_i32m1((int)outPtr[2 * n_vec], 1);
vint32m1_t accImagVal = __riscv_vmv_s_x_i32m1((int) outPtr[2 * n_vec + 1], 1); vint32m1_t accImagVal = __riscv_vmv_s_x_i32m1((int)outPtr[2 * n_vec + 1], 1);
// acc[0] = sum( acc[0], out[0..vl) ) // acc[0] = sum( acc[0], out[0..vl) )
accRealVal = __riscv_vwredsum_vs_i16m2_i32m1(outRealVal, accRealVal, vl); accRealVal = __riscv_vwredsum_vs_i16m2_i32m1(outRealVal, accRealVal, vl);
@@ -1012,8 +1010,8 @@ static inline void volk_gnsssdr_16ic_16i_rotator_dot_prod_16ic_xn_rvv(lv_16sc_t*
accImagVal = __riscv_vmax_vx_i32m1(accImagVal, -32768, 1); accImagVal = __riscv_vmax_vx_i32m1(accImagVal, -32768, 1);
// Store acc[0] // Store acc[0]
outPtr[2 * n_vec] = (short) __riscv_vmv_x_s_i32m1_i32(accRealVal); outPtr[2 * n_vec] = (short)__riscv_vmv_x_s_i32m1_i32(accRealVal);
outPtr[2 * n_vec + 1] = (short) __riscv_vmv_x_s_i32m1_i32(accImagVal); outPtr[2 * n_vec + 1] = (short)__riscv_vmv_x_s_i32m1_i32(accImagVal);
// Increment this pointer // Increment this pointer
inPtrBuf[n_vec] += vl; inPtrBuf[n_vec] += vl;

4
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_conjugate_16ic.h
View File

@@ -195,8 +195,8 @@ static inline void volk_gnsssdr_16ic_conjugate_16ic_rvv(lv_16sc_t* cVector, cons
size_t n = num_points; size_t n = num_points;
// Initialize pointers to keep track as stripmine // Initialize pointers to keep track as stripmine
short* cPtr = (short*) cVector; short* cPtr = (short*)cVector;
const short* aPtr = (short*) aVector; const short* aPtr = (short*)aVector;
for (size_t vl; n > 0; n -= vl, cPtr += vl * 2, aPtr += vl * 2) for (size_t vl; n > 0; n -= vl, cPtr += vl * 2, aPtr += vl * 2)
{ {

4
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_convert_32fc.h
View File

@@ -275,8 +275,8 @@ static inline void volk_gnsssdr_16ic_convert_32fc_rvv(lv_32fc_t* outputVector, c
size_t n = num_points * 2; size_t n = num_points * 2;
// Initialize pointers to keep track as stripmine // Initialize pointers to keep track as stripmine
float* outPtr = (float*) outputVector; float* outPtr = (float*)outputVector;
const short* inPtr = (const short*) inputVector; const short* inPtr = (const short*)inputVector;
for (size_t vl; n > 0; n -= vl, outPtr += vl, inPtr += vl) for (size_t vl; n > 0; n -= vl, outPtr += vl, inPtr += vl)
{ {

4
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_resampler_fast_16ic.h
View File

@@ -340,14 +340,14 @@ static inline void volk_gnsssdr_16ic_resampler_fast_16ic_rvv(lv_16sc_t* result,
// of each complex number as a single 32-bit number to move around // of each complex number as a single 32-bit number to move around
// Initialize reference pointer, as stays same and not stripmined // Initialize reference pointer, as stays same and not stripmined
const int* inPtr = (const int*) local_code; const int* inPtr = (const int*)local_code;
size_t n = num_output_samples; size_t n = num_output_samples;
const float constIndexShift = rem_code_phase_chips; const float constIndexShift = rem_code_phase_chips;
// Initialize pointer to track progress as stripmine // Initialize pointer to track progress as stripmine
int* outPtr = (int*) result; int* outPtr = (int*)result;
// Simulates how, compared to generic implementation, `i` continues // Simulates how, compared to generic implementation, `i` continues
// increasing across different vector computation batches // increasing across different vector computation batches
unsigned int currI = 0; unsigned int currI = 0;

10
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_s32fc_x2_rotator_16ic.h
View File

@@ -969,12 +969,12 @@ static inline void volk_gnsssdr_16ic_s32fc_x2_rotator_16ic_rvv(lv_16sc_t* outVec
size_t ROTATOR_RELOAD = 512; size_t ROTATOR_RELOAD = 512;
// Initialize reference pointers of compatible type that will not be stripmined // Initialize reference pointers of compatible type that will not be stripmined
float* phasePtr = (float*) phase; float* phasePtr = (float*)phase;
float* phaseIncPtr = (float*) phase_inc; float* phaseIncPtr = (float*)phase_inc;
// Initialize pointers of compatible type to track progress as stripmine // Initialize pointers of compatible type to track progress as stripmine
short* outPtr = (short*) outVector; short* outPtr = (short*)outVector;
const short* inPtr = (const short*) inVector; const short* inPtr = (const short*)inVector;
for (int _ = 0; _ < num_points / ROTATOR_RELOAD; _++) for (int _ = 0; _ < num_points / ROTATOR_RELOAD; _++)
{ {
@@ -1058,7 +1058,7 @@ static inline void volk_gnsssdr_16ic_s32fc_x2_rotator_16ic_rvv(lv_16sc_t* outVec
// numbers are each stored as two 16-bit numbers // numbers are each stored as two 16-bit numbers
} }
// Regenerate phase // Regenerate phase
#ifdef __cplusplus #ifdef __cplusplus
(*phase) /= std::abs((*phase)); (*phase) /= std::abs((*phase));
#else #else

10
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_dot_prod_16ic.h
View File

@@ -565,11 +565,11 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_rvv(lv_16sc_t* result, con
// Explicitly cast in order to directly fill // Explicitly cast in order to directly fill
// with calculated values // with calculated values
short* resPtr = (short*) result; short* resPtr = (short*)result;
// Initialize pointers to track progress as stripmine // Initialize pointers to track progress as stripmine
const short* aPtr = (const short*) in_a; const short* aPtr = (const short*)in_a;
const short* bPtr = (const short*) in_b; const short* bPtr = (const short*)in_b;
// Use 32-bit accumulator in order to saturate // Use 32-bit accumulator in order to saturate
// to 16 bits // to 16 bits
@@ -623,9 +623,9 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_rvv(lv_16sc_t* result, con
} }
// Real part of resultant complex number // Real part of resultant complex number
resPtr[0] = (short) __riscv_vmv_x_s_i32m1_i32(accRealVal); resPtr[0] = (short)__riscv_vmv_x_s_i32m1_i32(accRealVal);
// Imaginary part of resultant complex number // Imaginary part of resultant complex number
resPtr[1] = (short) __riscv_vmv_x_s_i32m1_i32(accImagVal); resPtr[1] = (short)__riscv_vmv_x_s_i32m1_i32(accImagVal);
} }
#endif /* LV_HAVE_RVV */ #endif /* LV_HAVE_RVV */

13
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_dot_prod_16ic_xn.h
View File

@@ -726,18 +726,19 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_neon_optvma(lv_16sc_t*
#ifdef LV_HAVE_RVV #ifdef LV_HAVE_RVV
#include <riscv_vector.h> #include <riscv_vector.h>
static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_rvv(lv_16sc_t* result, const lv_16sc_t* in_common, const lv_16sc_t** in_a, int num_a_vectors, unsigned int num_points) { static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_rvv(lv_16sc_t* result, const lv_16sc_t* in_common, const lv_16sc_t** in_a, int num_a_vectors, unsigned int num_points)
{
int n_vec = num_a_vectors; int n_vec = num_a_vectors;
for (int i = 0; i < n_vec; i++) for (int i = 0; i < n_vec; i++)
{ {
size_t n = num_points; size_t n = num_points;
short* resPtr = (short*) &result[i]; short* resPtr = (short*)&result[i];
// Initialize pointers to track progress as stripmine // Initialize pointers to track progress as stripmine
const short* comPtr = (const short*) in_common; const short* comPtr = (const short*)in_common;
const short* aPtr = (const short*) in_a[i]; const short* aPtr = (const short*)in_a[i];
// Use 32-bit accumulator in order to saturate // Use 32-bit accumulator in order to saturate
// to 16 bits // to 16 bits
@@ -791,9 +792,9 @@ static inline void volk_gnsssdr_16ic_x2_dot_prod_16ic_xn_rvv(lv_16sc_t* result,
} }
// Real part of resultant complex number // Real part of resultant complex number
resPtr[0] = (short) __riscv_vmv_x_s_i32m1_i32(accRealVal); resPtr[0] = (short)__riscv_vmv_x_s_i32m1_i32(accRealVal);
// Imaginary part of resultant complex number // Imaginary part of resultant complex number
resPtr[1] = (short) __riscv_vmv_x_s_i32m1_i32(accImagVal); resPtr[1] = (short)__riscv_vmv_x_s_i32m1_i32(accImagVal);
} }
} }
#endif /* LV_HAVE_RVV */ #endif /* LV_HAVE_RVV */

6
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_multiply_16ic.h
View File

@@ -335,9 +335,9 @@ static inline void volk_gnsssdr_16ic_x2_multiply_16ic_rvv(lv_16sc_t* result, con
size_t n = num_points; size_t n = num_points;
// Initialize pointers to keep track as stripmine // Initialize pointers to keep track as stripmine
short* resPtr = (short*) result; short* resPtr = (short*)result;
const short* aPtr = (const short*) in_a; const short* aPtr = (const short*)in_a;
const short* bPtr = (const short*) in_b; const short* bPtr = (const short*)in_b;
for (size_t vl; n > 0; n -= vl, resPtr += vl * 2, aPtr += vl * 2, bPtr += vl * 2) for (size_t vl; n > 0; n -= vl, resPtr += vl * 2, aPtr += vl * 2, bPtr += vl * 2)
{ {

43
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn.h
View File

@@ -1869,24 +1869,23 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_rvv(lv_16sc_t*
size_t ROTATOR_RELOAD = 256; size_t ROTATOR_RELOAD = 256;
// Initialize reference pointers of compatible type that will not be stripmined // Initialize reference pointers of compatible type that will not be stripmined
float* phasePtr = (float*) phase; float* phasePtr = (float*)phase;
// Initialize pointers of compatible type to track progress as stripmine // Initialize pointers of compatible type to track progress as stripmine
short* outPtr = (short*) result; short* outPtr = (short*)result;
const short* comPtr = (const short*) in_common; const short* comPtr = (const short*)in_common;
const short** inPtrBuf = (const short**) volk_gnsssdr_malloc( const short** inPtrBuf = (const short**)volk_gnsssdr_malloc(
num_a_vectors * sizeof(*in_a), volk_gnsssdr_get_alignment() num_a_vectors * sizeof(*in_a), volk_gnsssdr_get_alignment());
);
for (int n_vec = 0; n_vec < num_a_vectors; n_vec++) for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
{ {
// Initialize `out` to zero // Initialize `out` to zero
result[n_vec] = lv_cmake(0, 0); result[n_vec] = lv_cmake(0, 0);
// Treat complex number as struct containting // Treat complex number as struct containting
// two 16-bit integers // two 16-bit integers
inPtrBuf[n_vec] = (const short*) in_a[n_vec]; inPtrBuf[n_vec] = (const short*)in_a[n_vec];
} }
for (int _ = 0; _ < num_points / ROTATOR_RELOAD; _++) for (int _ = 0; _ < num_points / ROTATOR_RELOAD; _++)
{ {
@@ -1964,8 +1963,8 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_rvv(lv_16sc_t*
outImagVal = __riscv_vmacc_vv_i16m2(outImagVal, inImagVal, comProdRealVal, vl); outImagVal = __riscv_vmacc_vv_i16m2(outImagVal, inImagVal, comProdRealVal, vl);
// Load accumulator // Load accumulator
vint32m1_t accRealVal = __riscv_vmv_s_x_i32m1((int) outPtr[2 * n_vec], 1); vint32m1_t accRealVal = __riscv_vmv_s_x_i32m1((int)outPtr[2 * n_vec], 1);
vint32m1_t accImagVal = __riscv_vmv_s_x_i32m1((int) outPtr[2 * n_vec + 1], 1); vint32m1_t accImagVal = __riscv_vmv_s_x_i32m1((int)outPtr[2 * n_vec + 1], 1);
// acc[0] = sum( acc[0], out[0..vl) ) // acc[0] = sum( acc[0], out[0..vl) )
accRealVal = __riscv_vwredsum_vs_i16m2_i32m1(outRealVal, accRealVal, vl); accRealVal = __riscv_vwredsum_vs_i16m2_i32m1(outRealVal, accRealVal, vl);
@@ -1980,8 +1979,8 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_rvv(lv_16sc_t*
accImagVal = __riscv_vmax_vx_i32m1(accImagVal, -32768, 1); accImagVal = __riscv_vmax_vx_i32m1(accImagVal, -32768, 1);
// Store acc[0] // Store acc[0]
outPtr[2 * n_vec] = (short) __riscv_vmv_x_s_i32m1_i32(accRealVal); outPtr[2 * n_vec] = (short)__riscv_vmv_x_s_i32m1_i32(accRealVal);
outPtr[2 * n_vec + 1] = (short) __riscv_vmv_x_s_i32m1_i32(accImagVal); outPtr[2 * n_vec + 1] = (short)__riscv_vmv_x_s_i32m1_i32(accImagVal);
// Increment this pointer, accounting how each complex // Increment this pointer, accounting how each complex
// element is two 16-bit integer numbers // element is two 16-bit integer numbers
@@ -2001,7 +2000,7 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_rvv(lv_16sc_t*
// elements left and increment the pointers // elements left and increment the pointers
// by the number of elements processed // by the number of elements processed
} }
// Regenerate phase // Regenerate phase
#ifdef __cplusplus #ifdef __cplusplus
(*phase) /= std::abs((*phase)); (*phase) /= std::abs((*phase));
#else #else
@@ -2083,8 +2082,8 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_rvv(lv_16sc_t*
outImagVal = __riscv_vmacc_vv_i16m2(outImagVal, inImagVal, comProdRealVal, vl); outImagVal = __riscv_vmacc_vv_i16m2(outImagVal, inImagVal, comProdRealVal, vl);
// Load accumulator // Load accumulator
vint32m1_t accRealVal = __riscv_vmv_s_x_i32m1((int) outPtr[2 * n_vec], 1); vint32m1_t accRealVal = __riscv_vmv_s_x_i32m1((int)outPtr[2 * n_vec], 1);
vint32m1_t accImagVal = __riscv_vmv_s_x_i32m1((int) outPtr[2 * n_vec + 1], 1); vint32m1_t accImagVal = __riscv_vmv_s_x_i32m1((int)outPtr[2 * n_vec + 1], 1);
// acc[0] = sum( acc[0], out[0..vl) ) // acc[0] = sum( acc[0], out[0..vl) )
accRealVal = __riscv_vwredsum_vs_i16m2_i32m1(outRealVal, accRealVal, vl); accRealVal = __riscv_vwredsum_vs_i16m2_i32m1(outRealVal, accRealVal, vl);
@@ -2099,8 +2098,8 @@ static inline void volk_gnsssdr_16ic_x2_rotator_dot_prod_16ic_xn_rvv(lv_16sc_t*
accImagVal = __riscv_vmax_vx_i32m1(accImagVal, -32768, 1); accImagVal = __riscv_vmax_vx_i32m1(accImagVal, -32768, 1);
// Store acc[0] // Store acc[0]
outPtr[2 * n_vec] = (short) __riscv_vmv_x_s_i32m1_i32(accRealVal); outPtr[2 * n_vec] = (short)__riscv_vmv_x_s_i32m1_i32(accRealVal);
outPtr[2 * n_vec + 1] = (short) __riscv_vmv_x_s_i32m1_i32(accImagVal); outPtr[2 * n_vec + 1] = (short)__riscv_vmv_x_s_i32m1_i32(accImagVal);
// Increment this pointer, accounting how each complex // Increment this pointer, accounting how each complex
// element is two 16-bit integer numbers // element is two 16-bit integer numbers

4
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_xn_resampler_16ic_xn.h
View File

@@ -605,7 +605,7 @@ static inline void volk_gnsssdr_16ic_xn_resampler_16ic_xn_rvv(lv_16sc_t** result
// of each complex number as a single 32-bit number to move around // of each complex number as a single 32-bit number to move around
// Initialize reference pointer, as stays same across loops // Initialize reference pointer, as stays same across loops
const int* inPtr = (const int*) local_code; const int* inPtr = (const int*)local_code;
for (int current_correlator_tap = 0; current_correlator_tap < num_out_vectors; current_correlator_tap++) for (int current_correlator_tap = 0; current_correlator_tap < num_out_vectors; current_correlator_tap++)
{ {
@@ -614,7 +614,7 @@ static inline void volk_gnsssdr_16ic_xn_resampler_16ic_xn_rvv(lv_16sc_t** result
const float constIndexShift = shifts_chips[current_correlator_tap] - rem_code_phase_chips; const float constIndexShift = shifts_chips[current_correlator_tap] - rem_code_phase_chips;
// Initialize pointers to track progress as stripmine // Initialize pointers to track progress as stripmine
int* outPtr = (int*) result[current_correlator_tap]; int* outPtr = (int*)result[current_correlator_tap];
// Simulates how, compared to generic implementation, `i` continues // Simulates how, compared to generic implementation, `i` continues
// increasing across different vector computatation batches // increasing across different vector computatation batches
unsigned int currI = 0; unsigned int currI = 0;

6
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_16ic_xn_resampler_fast_16ic_xn.h
View File

@@ -382,10 +382,10 @@ static inline void volk_gnsssdr_16ic_xn_resampler_fast_16ic_xn_rvv(lv_16sc_t** r
// of each complex number as a single 32-bit number to move around // of each complex number as a single 32-bit number to move around
// Initialize reference pointer, as stays same and not stripmined // Initialize reference pointer, as stays same and not stripmined
const int* inPtr = (const int*) local_code; const int* inPtr = (const int*)local_code;
// Initialize variable to clearer, applicable type // Initialize variable to clearer, applicable type
int code_len = (int) code_length_chips; int code_len = (int)code_length_chips;
for (int current_vector = 0; current_vector < num_out_vectors; current_vector++) for (int current_vector = 0; current_vector < num_out_vectors; current_vector++)
{ {
@@ -394,7 +394,7 @@ static inline void volk_gnsssdr_16ic_xn_resampler_fast_16ic_xn_rvv(lv_16sc_t** r
const float constIndexShift = rem_code_phase_chips[current_vector]; const float constIndexShift = rem_code_phase_chips[current_vector];
// Initialize pointer to track progress as stripmine // Initialize pointer to track progress as stripmine
int* outPtr = (int*) result[current_vector]; int* outPtr = (int*)result[current_vector];
// Simulates how, compared to generic implementation, `i` continues // Simulates how, compared to generic implementation, `i` continues
// increasing across different vector computation batches // increasing across different vector computation batches
unsigned int currI = 0; unsigned int currI = 0;

12
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_32f_sincos_32fc.h
View File

@@ -755,7 +755,7 @@ static inline void volk_gnsssdr_32f_sincos_32fc_rvv(lv_32fc_t* out, const float*
size_t n = num_points; size_t n = num_points;
// Initialize pointers to keep track as stripmine // Initialize pointers to keep track as stripmine
float* outPtr = (float*) out; float* outPtr = (float*)out;
const float* inPtr = in; const float* inPtr = in;
for (size_t vl; n > 0; n -= vl, outPtr += vl * 2, inPtr += vl) for (size_t vl; n > 0; n -= vl, outPtr += vl * 2, inPtr += vl)
@@ -768,7 +768,7 @@ static inline void volk_gnsssdr_32f_sincos_32fc_rvv(lv_32fc_t* out, const float*
// Save initial signs // Save initial signs
// signMask[i] = in[i] < 0 // signMask[i] = in[i] < 0
vbool8_t signMask = __riscv_vmflt_vf_f32m4_b8(inVal, (float) 0, vl); vbool8_t signMask = __riscv_vmflt_vf_f32m4_b8(inVal, (float)0, vl);
// x[i] = |in[i]| // x[i] = |in[i]|
vfloat32m4_t xVal = __riscv_vfabs_v_f32m4(inVal, vl); vfloat32m4_t xVal = __riscv_vfabs_v_f32m4(inVal, vl);
@@ -843,11 +843,9 @@ static inline void volk_gnsssdr_32f_sincos_32fc_rvv(lv_32fc_t* out, const float*
// outImag[i] = sinSignMask ? -sin[i] : sin[i] // outImag[i] = sinSignMask ? -sin[i] : sin[i]
// outReal[i] = cosSignMask ? cos[i] : -cos[i] // outReal[i] = cosSignMask ? cos[i] : -cos[i]
vfloat32m4_t outImagVal = __riscv_vmerge_vvm_f32m4( vfloat32m4_t outImagVal = __riscv_vmerge_vvm_f32m4(
sinVal, __riscv_vfneg_v_f32m4(sinVal, vl), sinSignMask, vl sinVal, __riscv_vfneg_v_f32m4(sinVal, vl), sinSignMask, vl);
);
vfloat32m4_t outRealVal = __riscv_vmerge_vvm_f32m4( vfloat32m4_t outRealVal = __riscv_vmerge_vvm_f32m4(
__riscv_vfneg_v_f32m4(cosVal, vl), cosVal, cosSignMask, vl __riscv_vfneg_v_f32m4(cosVal, vl), cosVal, cosSignMask, vl);
);
// Store out[0..vl) // Store out[0..vl)
vfloat32m4x2_t outVal = __riscv_vcreate_v_f32m4x2(outRealVal, outImagVal); vfloat32m4x2_t outVal = __riscv_vcreate_v_f32m4x2(outRealVal, outImagVal);
@@ -856,7 +854,7 @@ static inline void volk_gnsssdr_32f_sincos_32fc_rvv(lv_32fc_t* out, const float*
// In looping, decrement the number of // In looping, decrement the number of
// elements left and increment the pointers // elements left and increment the pointers
// by the number of elements processed, // by the number of elements processed,
// taking into account how the output `vl` // taking into account how the output `vl`
// complex numbers are stored as 2 `float`s // complex numbers are stored as 2 `float`s
} }
} }

2
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_32f_xn_high_dynamics_resampler_32f_xn.h
View File

@@ -78,7 +78,7 @@ static inline void volk_gnsssdr_32f_xn_high_dynamics_resampler_32f_xn_generic(fl
if (local_code_chip_index < 0) local_code_chip_index += (int)code_length_chips * (abs(local_code_chip_index) / code_length_chips + 1); if (local_code_chip_index < 0) local_code_chip_index += (int)code_length_chips * (abs(local_code_chip_index) / code_length_chips + 1);
local_code_chip_index = local_code_chip_index % code_length_chips; local_code_chip_index = local_code_chip_index % code_length_chips;
result[0][n] = local_code[local_code_chip_index]; result[0][n] = local_code[local_code_chip_index];
} }
// adjacent correlators // adjacent correlators
unsigned int shift_samples = 0; unsigned int shift_samples = 0;

29
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn.h
View File

@@ -492,24 +492,23 @@ static inline void volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_rvv(lv_32fc_t*
size_t ROTATOR_RELOAD = 256; size_t ROTATOR_RELOAD = 256;
// Initialize reference pointers of compatible type that will not be stripmined // Initialize reference pointers of compatible type that will not be stripmined
float* phasePtr = (float*) phase; float* phasePtr = (float*)phase;
// Initialize pointers of compatible type to track progress as stripmine // Initialize pointers of compatible type to track progress as stripmine
float* outPtr = (float*) result; float* outPtr = (float*)result;
const float* comPtr = (const float*) in_common; const float* comPtr = (const float*)in_common;
const float** inPtrBuf = (const float**) volk_gnsssdr_malloc( const float** inPtrBuf = (const float**)volk_gnsssdr_malloc(
num_a_vectors * sizeof(*in_a), volk_gnsssdr_get_alignment() num_a_vectors * sizeof(*in_a), volk_gnsssdr_get_alignment());
);
for (int n_vec = 0; n_vec < num_a_vectors; n_vec++) for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
{ {
// Initialize `out` to zero // Initialize `out` to zero
result[n_vec] = lv_cmake(0.0f, 0.0f); result[n_vec] = lv_cmake(0.0f, 0.0f);
// Treat complex number as struct containting // Treat complex number as struct containting
// two 16-bit integers // two 16-bit integers
inPtrBuf[n_vec] = in_a[n_vec]; inPtrBuf[n_vec] = in_a[n_vec];
} }
for (int _ = 0; _ < num_points / ROTATOR_RELOAD; _++) for (int _ = 0; _ < num_points / ROTATOR_RELOAD; _++)
{ {
@@ -602,8 +601,8 @@ static inline void volk_gnsssdr_32fc_32f_rotator_dot_prod_32fc_xn_rvv(lv_32fc_t*
// In looping, decrement the number of // In looping, decrement the number of
// elements left and increment the pointers // elements left and increment the pointers
// by the number of elements processed // by the number of elements processed
} }
// Regenerate phase // Regenerate phase
#ifdef __cplusplus #ifdef __cplusplus
(*phase) /= std::abs((*phase)); (*phase) /= std::abs((*phase));
#else #else

8
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_32fc_convert_16ic.h
View File

@@ -471,8 +471,8 @@ static inline void volk_gnsssdr_32fc_convert_16ic_rvv(lv_16sc_t* outputVector, c
size_t n = num_points * 2; size_t n = num_points * 2;
// Initialize pointers to keep track as stripmine // Initialize pointers to keep track as stripmine
short* outPtr = (short*) outputVector; short* outPtr = (short*)outputVector;
const float* inPtr = (const float*) inputVector; const float* inPtr = (const float*)inputVector;
for (size_t vl; n > 0; n -= vl, outPtr += vl, inPtr += vl) for (size_t vl; n > 0; n -= vl, outPtr += vl, inPtr += vl)
{ {
@@ -485,8 +485,8 @@ static inline void volk_gnsssdr_32fc_convert_16ic_rvv(lv_16sc_t* outputVector, c
vfloat32m8_t inVal = __riscv_vle32_v_f32m8(inPtr, vl); vfloat32m8_t inVal = __riscv_vle32_v_f32m8(inPtr, vl);
// Saturate in[i] to 16 bits // Saturate in[i] to 16 bits
inVal = __riscv_vfmin_vf_f32m8(inVal, (float) 32767, vl); inVal = __riscv_vfmin_vf_f32m8(inVal, (float)32767, vl);
inVal = __riscv_vfmax_vf_f32m8(inVal, (float) -32768, vl); inVal = __riscv_vfmax_vf_f32m8(inVal, (float)-32768, vl);
// out[i] = (short) in[i] // out[i] = (short) in[i]
vint16m4_t outVal = __riscv_vfncvt_x_f_w_i16m4(inVal, vl); vint16m4_t outVal = __riscv_vfncvt_x_f_w_i16m4(inVal, vl);

10
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_32fc_convert_8ic.h
View File

@@ -464,8 +464,8 @@ static inline void volk_gnsssdr_32fc_convert_8ic_rvv(lv_8sc_t* outputVector, con
// Initialize pointers to keep track as stripmine // Initialize pointers to keep track as stripmine
// Assuming `signed char` is intended, as `char`'s // Assuming `signed char` is intended, as `char`'s
// signedness is implementation-based // signedness is implementation-based
signed char* outPtr = (signed char*) outputVector; signed char* outPtr = (signed char*)outputVector;
const float* inPtr = (const float*) inputVector; const float* inPtr = (const float*)inputVector;
for (size_t vl; n > 0; n -= vl, outPtr += vl, inPtr += vl) for (size_t vl; n > 0; n -= vl, outPtr += vl, inPtr += vl)
{ {
@@ -480,11 +480,11 @@ static inline void volk_gnsssdr_32fc_convert_8ic_rvv(lv_8sc_t* outputVector, con
// For some reason, generic implementation // For some reason, generic implementation
// multiplies float by `INT8_MAX` before converting // multiplies float by `INT8_MAX` before converting
// tmp[i] *= INT8_MAX // tmp[i] *= INT8_MAX
vfloat32m8_t tmp32Val = __riscv_vfmul_vf_f32m8(inVal, (float) 127, vl); vfloat32m8_t tmp32Val = __riscv_vfmul_vf_f32m8(inVal, (float)127, vl);
// Saturate tmp[i] to 8 bits // Saturate tmp[i] to 8 bits
tmp32Val = __riscv_vfmin_vf_f32m8(tmp32Val, (float) 127, vl); tmp32Val = __riscv_vfmin_vf_f32m8(tmp32Val, (float)127, vl);
tmp32Val = __riscv_vfmax_vf_f32m8(tmp32Val, (float) -128, vl); tmp32Val = __riscv_vfmax_vf_f32m8(tmp32Val, (float)-128, vl);
// out[i] = (signed char) tmp[i] // out[i] = (signed char) tmp[i]
vint16m4_t tmp16Val = __riscv_vfncvt_x_f_w_i16m4(tmp32Val, vl); vint16m4_t tmp16Val = __riscv_vfncvt_x_f_w_i16m4(tmp32Val, vl);

27
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn.h
View File

@@ -797,24 +797,23 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_rvv(lv_32fc_t*
size_t ROTATOR_RELOAD = 256; size_t ROTATOR_RELOAD = 256;
// Initialize reference pointers of compatible type that will not be stripmined // Initialize reference pointers of compatible type that will not be stripmined
float* phasePtr = (float*) phase; float* phasePtr = (float*)phase;
// Initialize pointers of compatible type to track progress as stripmine // Initialize pointers of compatible type to track progress as stripmine
float* outPtr = (float*) result; float* outPtr = (float*)result;
const float* comPtr = (const float*) in_common; const float* comPtr = (const float*)in_common;
const float** inPtrBuf = (const float**) volk_gnsssdr_malloc( const float** inPtrBuf = (const float**)volk_gnsssdr_malloc(
num_a_vectors * sizeof(*in_a), volk_gnsssdr_get_alignment() num_a_vectors * sizeof(*in_a), volk_gnsssdr_get_alignment());
);
for (int n_vec = 0; n_vec < num_a_vectors; n_vec++) for (int n_vec = 0; n_vec < num_a_vectors; n_vec++)
{ {
// Initialize `out` to zero // Initialize `out` to zero
result[n_vec] = lv_cmake(0.0f, 0.0f); result[n_vec] = lv_cmake(0.0f, 0.0f);
// Treat complex number as struct containting // Treat complex number as struct containting
// two 16-bit integers // two 16-bit integers
inPtrBuf[n_vec] = (float*) in_a[n_vec]; inPtrBuf[n_vec] = (float*)in_a[n_vec];
} }
for (int _ = 0; _ < num_points / ROTATOR_RELOAD; _++) for (int _ = 0; _ < num_points / ROTATOR_RELOAD; _++)
{ {
@@ -913,7 +912,7 @@ static inline void volk_gnsssdr_32fc_x2_rotator_dot_prod_32fc_xn_rvv(lv_32fc_t*
// elements left and increment the pointers // elements left and increment the pointers
// by the number of elements processed // by the number of elements processed
} }
// Regenerate phase // Regenerate phase
#ifdef __cplusplus #ifdef __cplusplus
(*phase) /= std::abs((*phase)); (*phase) /= std::abs((*phase));
#else #else

4
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_32fc_xn_resampler_32fc_xn.h
View File

@@ -764,7 +764,7 @@ static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_rvv(lv_32fc_t** result
// of each complex number as a single 64-bit number to move around // of each complex number as a single 64-bit number to move around
// Initialize reference pointer, as stays same across loops // Initialize reference pointer, as stays same across loops
const long* inPtr = (const long*) local_code; const long* inPtr = (const long*)local_code;
for (int current_correlator_tap = 0; current_correlator_tap < num_out_vectors; current_correlator_tap++) for (int current_correlator_tap = 0; current_correlator_tap < num_out_vectors; current_correlator_tap++)
{ {
@@ -773,7 +773,7 @@ static inline void volk_gnsssdr_32fc_xn_resampler_32fc_xn_rvv(lv_32fc_t** result
const float constIndexShift = shifts_chips[current_correlator_tap] - rem_code_phase_chips; const float constIndexShift = shifts_chips[current_correlator_tap] - rem_code_phase_chips;
// Initialize pointers to track progress as stripmine // Initialize pointers to track progress as stripmine
long* outPtr = (long*) result[current_correlator_tap]; long* outPtr = (long*)result[current_correlator_tap];
// Simulates how, compared to generic implementation, `i` continues // Simulates how, compared to generic implementation, `i` continues
// increasing across different vector computatation batches // increasing across different vector computatation batches
unsigned int currI = 0; unsigned int currI = 0;

2
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_64f_accumulator_64f.h
View File

@@ -233,7 +233,7 @@ static inline void volk_gnsssdr_64f_accumulator_64f_rvv(double* result, const do
const double* inPtr = inputBuffer; const double* inPtr = inputBuffer;
// acc[0] = 0 // acc[0] = 0
vfloat64m1_t accVal = __riscv_vfmv_v_f_f64m1((double) 0, 1); vfloat64m1_t accVal = __riscv_vfmv_v_f_f64m1((double)0, 1);
for (size_t vl; n > 0; n -= vl, inPtr += vl) for (size_t vl; n > 0; n -= vl, inPtr += vl)
{ {

4
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_8i_accumulator_s8i.h
View File

@@ -228,7 +228,7 @@ static inline void volk_gnsssdr_8i_accumulator_s8i_rvv(char* result, const char*
// Initialize pointer of correct type // Initialize pointer of correct type
// to keep track while stripmining // to keep track while stripmining
const signed char* inPtr = (const signed char*) inputBuffer; const signed char* inPtr = (const signed char*)inputBuffer;
// acc[0] = 0 // acc[0] = 0
vint8m1_t accVal = __riscv_vmv_v_x_i8m1(0, 1); vint8m1_t accVal = __riscv_vmv_v_x_i8m1(0, 1);
@@ -251,7 +251,7 @@ static inline void volk_gnsssdr_8i_accumulator_s8i_rvv(char* result, const char*
} }
// Explicitly cast to type accepted by macro // Explicitly cast to type accepted by macro
signed char* resPtr = (signed char*) result; signed char* resPtr = (signed char*)result;
// *result = acc[0] // *result = acc[0]
// NOTE: With this implementation, // NOTE: With this implementation,

6
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_8i_x2_add_8i.h
View File

@@ -215,9 +215,9 @@ static inline void volk_gnsssdr_8i_x2_add_8i_rvv(char* cVector, const char* aVec
// Initialize pointers to track progress as stripmine // Initialize pointers to track progress as stripmine
// Macro expects `int8_t`, and `char`'s signedness // Macro expects `int8_t`, and `char`'s signedness
// depends on implementation // depends on implementation
signed char* cPtr = (signed char*) cVector; // For consistency signed char* cPtr = (signed char*)cVector; // For consistency
const signed char* aPtr = (const signed char*) aVector; const signed char* aPtr = (const signed char*)aVector;
const signed char* bPtr = (const signed char*) bVector; const signed char* bPtr = (const signed char*)bVector;
for (size_t vl; n > 0; n -= vl, cPtr += vl, aPtr += vl, bPtr += vl) for (size_t vl; n > 0; n -= vl, cPtr += vl, aPtr += vl, bPtr += vl)
{ {

4
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_8ic_conjugate_8ic.h
View File

@@ -363,8 +363,8 @@ static inline void volk_gnsssdr_8ic_conjugate_8ic_rvv(lv_8sc_t* cVector, const l
// Initialize pointers to track progress as stripmine // Initialize pointers to track progress as stripmine
// Assuming that intended to use `signed char`, // Assuming that intended to use `signed char`,
// as `char`'s signedness is implementation-specific // as `char`'s signedness is implementation-specific
signed char* cPtr = (signed char*) cVector; signed char* cPtr = (signed char*)cVector;
const signed char* aPtr = (const signed char*) aVector; const signed char* aPtr = (const signed char*)aVector;
for (size_t vl; n > 0; n -= vl, cPtr += vl * 2, aPtr += vl * 2) for (size_t vl; n > 0; n -= vl, cPtr += vl * 2, aPtr += vl * 2)
{ {

4
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_8ic_magnitude_squared_8i.h
View File

@@ -185,8 +185,8 @@ static inline void volk_gnsssdr_8ic_magnitude_squared_8i_rvv(char* magnitudeVect
// Initialize pointers to track progress as stripmine // Initialize pointers to track progress as stripmine
// Assuming that intended to use `signed char`, // Assuming that intended to use `signed char`,
// as `char`'s signedness is implementation-specific // as `char`'s signedness is implementation-specific
signed char* outPtr = (signed char*) magnitudeVector; signed char* outPtr = (signed char*)magnitudeVector;
const signed char* inPtr = (const signed char*) complexVector; const signed char* inPtr = (const signed char*)complexVector;
for (size_t vl; n > 0; n -= vl, outPtr += vl, inPtr += vl * 2) for (size_t vl; n > 0; n -= vl, outPtr += vl, inPtr += vl * 2)
{ {

6
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_8ic_x2_dot_prod_8ic.h
View File

@@ -493,13 +493,13 @@ static inline void volk_gnsssdr_8ic_x2_dot_prod_8ic_rvv(lv_8sc_t* result, const
// Explicitly cast in order to directly fill // Explicitly cast in order to directly fill
// with calculated values // with calculated values
signed char* resPtr = (signed char*) result; signed char* resPtr = (signed char*)result;
// Initialize pointers to track progress as stripmine // Initialize pointers to track progress as stripmine
// Assuming that intended to use `signed char`, // Assuming that intended to use `signed char`,
// as `char`'s signedness is implementation-specific // as `char`'s signedness is implementation-specific
const signed char* aPtr = (const signed char*) in_a; const signed char* aPtr = (const signed char*)in_a;
const signed char* bPtr = (const signed char*) in_b; const signed char* bPtr = (const signed char*)in_b;
// accReal[0] = 0 // accReal[0] = 0
vint8m1_t accRealVal = __riscv_vmv_s_x_i8m1(0, 1); vint8m1_t accRealVal = __riscv_vmv_s_x_i8m1(0, 1);

66
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_8ic_x2_multiply_8ic.h
View File

@@ -290,52 +290,54 @@ static inline void volk_gnsssdr_8ic_x2_multiply_8ic_a_sse4_1(lv_8sc_t* cVector,
#ifdef LV_HAVE_RVV #ifdef LV_HAVE_RVV
#include <riscv_vector.h> #include <riscv_vector.h>
static inline void volk_gnsssdr_8ic_x2_multiply_8ic_rvv(lv_8sc_t* cVector, const lv_8sc_t* aVector, const lv_8sc_t* bVector, unsigned int num_points) { static inline void volk_gnsssdr_8ic_x2_multiply_8ic_rvv(lv_8sc_t* cVector, const lv_8sc_t* aVector, const lv_8sc_t* bVector, unsigned int num_points)
{
size_t n = num_points; size_t n = num_points;
// Initialize pointers to track progress as stripmine // Initialize pointers to track progress as stripmine
// Assuming that intended to use `signed char` // Assuming that intended to use `signed char`
// as `char`'s signedness is implementation-specific // as `char`'s signedness is implementation-specific
signed char* cPtr = (signed char*) cVector; signed char* cPtr = (signed char*)cVector;
const signed char* aPtr = (const signed char*) aVector; const signed char* aPtr = (const signed char*)aVector;
const signed char* bPtr = (const signed char*) bVector; const signed char* bPtr = (const signed char*)bVector;
for (size_t vl; n > 0; n -= vl, cPtr += vl * 2, aPtr += vl * 2, bPtr += vl * 2) { for (size_t vl; n > 0; n -= vl, cPtr += vl * 2, aPtr += vl * 2, bPtr += vl * 2)
// Record how many elements will actually be processed {
vl = __riscv_vsetvl_e8m4(n); // Record how many elements will actually be processed
vl = __riscv_vsetvl_e8m4(n);
// Load aReal[0..vl), aImag[0..vl) // Load aReal[0..vl), aImag[0..vl)
vint8m4x2_t aVal = __riscv_vlseg2e8_v_i8m4x2(aPtr, vl); vint8m4x2_t aVal = __riscv_vlseg2e8_v_i8m4x2(aPtr, vl);
vint8m4_t aRealVal = __riscv_vget_v_i8m4x2_i8m4(aVal, 0); vint8m4_t aRealVal = __riscv_vget_v_i8m4x2_i8m4(aVal, 0);
vint8m4_t aImagVal = __riscv_vget_v_i8m4x2_i8m4(aVal, 1); vint8m4_t aImagVal = __riscv_vget_v_i8m4x2_i8m4(aVal, 1);
// Load bReal[0..vl), bImag[0..vl) // Load bReal[0..vl), bImag[0..vl)
vint8m4x2_t bVal = __riscv_vlseg2e8_v_i8m4x2(bPtr, vl); vint8m4x2_t bVal = __riscv_vlseg2e8_v_i8m4x2(bPtr, vl);
vint8m4_t bRealVal = __riscv_vget_v_i8m4x2_i8m4(bVal, 0); vint8m4_t bRealVal = __riscv_vget_v_i8m4x2_i8m4(bVal, 0);
vint8m4_t bImagVal = __riscv_vget_v_i8m4x2_i8m4(bVal, 1); vint8m4_t bImagVal = __riscv_vget_v_i8m4x2_i8m4(bVal, 1);
// cReal[i] = aReal[i] * bReal[i] // cReal[i] = aReal[i] * bReal[i]
vint8m4_t cRealVal = __riscv_vmul_vv_i8m4(aRealVal, bRealVal, vl); vint8m4_t cRealVal = __riscv_vmul_vv_i8m4(aRealVal, bRealVal, vl);
// cReal[i] = -(aImag[i] * bImag[i]) + cReal[i] // cReal[i] = -(aImag[i] * bImag[i]) + cReal[i]
cRealVal = __riscv_vnmsac_vv_i8m4(cRealVal, aImagVal, bImagVal, vl); cRealVal = __riscv_vnmsac_vv_i8m4(cRealVal, aImagVal, bImagVal, vl);
// cImag[i] = aReal[i] * bImag[i] // cImag[i] = aReal[i] * bImag[i]
vint8m4_t cImagVal = __riscv_vmul_vv_i8m4(aRealVal, bImagVal, vl); vint8m4_t cImagVal = __riscv_vmul_vv_i8m4(aRealVal, bImagVal, vl);
// cImag[i] = (aImag[i] * bReal[i]) + cImag[i] // cImag[i] = (aImag[i] * bReal[i]) + cImag[i]
cImagVal = __riscv_vmacc_vv_i8m4(cImagVal, aImagVal, bRealVal, vl); cImagVal = __riscv_vmacc_vv_i8m4(cImagVal, aImagVal, bRealVal, vl);
// Store cReal[0..vl), cImag[0..vl) // Store cReal[0..vl), cImag[0..vl)
vint8m4x2_t cVal = __riscv_vcreate_v_i8m4x2(cRealVal, cImagVal); vint8m4x2_t cVal = __riscv_vcreate_v_i8m4x2(cRealVal, cImagVal);
__riscv_vsseg2e8_v_i8m4x2(cPtr, cVal, vl); __riscv_vsseg2e8_v_i8m4x2(cPtr, cVal, vl);
// In looping, decrement the number of // In looping, decrement the number of
// elements left and increment the pointers // elements left and increment the pointers
// by the number of elements processed, // by the number of elements processed,
// taking into account how the `vl` complex // taking into account how the `vl` complex
// numbers are each stored as two 1-byte `char`s // numbers are each stored as two 1-byte `char`s
} }
} }
#endif /* LV_HAVE_RVV */ #endif /* LV_HAVE_RVV */

1
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_8u_x2_multiply_8u.h
View File

@@ -263,7 +263,6 @@ static inline void volk_gnsssdr_8u_x2_multiply_8u_a_avx2(unsigned char* cChar, c
#endif /* LV_HAVE_SSE3 */ #endif /* LV_HAVE_SSE3 */
#ifdef LV_HAVE_RVV #ifdef LV_HAVE_RVV
#include <riscv_vector.h> #include <riscv_vector.h>

16
src/algorithms/libs/volk_gnsssdr_module/volk_gnsssdr/kernels/volk_gnsssdr/volk_gnsssdr_s32f_sincos_32fc.h
View File

@@ -937,7 +937,7 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_neon(lv_32fc_t *out, const floa
#include <riscv_vector.h> #include <riscv_vector.h>
// Reverse-engineered from NEON implementation // Reverse-engineered from NEON implementation
static inline void volk_gnsssdr_s32f_sincos_32fc_rvv(lv_32fc_t* out, const float phase_inc, float* phase, unsigned int num_points) static inline void volk_gnsssdr_s32f_sincos_32fc_rvv(lv_32fc_t *out, const float phase_inc, float *phase, unsigned int num_points)
{ {
// Copied from other implementations, specifically NEON // Copied from other implementations, specifically NEON
const float c_minus_cephes_DP1 = -0.78515625; const float c_minus_cephes_DP1 = -0.78515625;
@@ -954,10 +954,10 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_rvv(lv_32fc_t* out, const float
size_t n = num_points; size_t n = num_points;
// Initialize other pointers for consistency // Initialize other pointers for consistency
float* phasePtr = phase; float *phasePtr = phase;
// Initialize pointers to keep track as stripmine // Initialize pointers to keep track as stripmine
float* outPtr = (float*) out; float *outPtr = (float *)out;
for (size_t vl; n > 0; n -= vl, outPtr += vl * 2) for (size_t vl; n > 0; n -= vl, outPtr += vl * 2)
{ {
@@ -979,7 +979,7 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_rvv(lv_32fc_t* out, const float
// Save initial signs // Save initial signs
// signMask[i] = phase[i] < 0 // signMask[i] = phase[i] < 0
vbool8_t signMask = __riscv_vmflt_vf_f32m4_b8(phaseVal, (float) 0, vl); vbool8_t signMask = __riscv_vmflt_vf_f32m4_b8(phaseVal, (float)0, vl);
// x[i] = |phase[i]| // x[i] = |phase[i]|
vfloat32m4_t xVal = __riscv_vfabs_v_f32m4(phaseVal, vl); vfloat32m4_t xVal = __riscv_vfabs_v_f32m4(phaseVal, vl);
@@ -1054,11 +1054,9 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_rvv(lv_32fc_t* out, const float
// outImag[i] = sinSignMask ? -sin[i] : sin[i] // outImag[i] = sinSignMask ? -sin[i] : sin[i]
// outReal[i] = cosSignMask ? cos[i] : -cos[i] // outReal[i] = cosSignMask ? cos[i] : -cos[i]
vfloat32m4_t outImagVal = __riscv_vmerge_vvm_f32m4( vfloat32m4_t outImagVal = __riscv_vmerge_vvm_f32m4(
sinVal, __riscv_vfneg_v_f32m4(sinVal, vl), sinSignMask, vl sinVal, __riscv_vfneg_v_f32m4(sinVal, vl), sinSignMask, vl);
);
vfloat32m4_t outRealVal = __riscv_vmerge_vvm_f32m4( vfloat32m4_t outRealVal = __riscv_vmerge_vvm_f32m4(
__riscv_vfneg_v_f32m4(cosVal, vl), cosVal, cosSignMask, vl __riscv_vfneg_v_f32m4(cosVal, vl), cosVal, cosSignMask, vl);
);
// Store out[0..vl) // Store out[0..vl)
vfloat32m4x2_t outVal = __riscv_vcreate_v_f32m4x2(outRealVal, outImagVal); vfloat32m4x2_t outVal = __riscv_vcreate_v_f32m4x2(outRealVal, outImagVal);
@@ -1074,7 +1072,7 @@ static inline void volk_gnsssdr_s32f_sincos_32fc_rvv(lv_32fc_t* out, const float
// In looping, decrement the number of // In looping, decrement the number of
// elements left and increment the pointers // elements left and increment the pointers
// by the number of elements processed, // by the number of elements processed,
// taking into account how the output `vl` // taking into account how the output `vl`
// complex numbers are stored as 2 `float`s // complex numbers are stored as 2 `float`s
} }
} }