From 2fcd5380826acd7667b3b13c488d21a0f32b9ac5 Mon Sep 17 00:00:00 2001 From: rmagueta Date: Fri, 12 May 2023 14:52:10 +0100 Subject: [PATCH 01/47] SRS processing time measurement --- openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_ulsch.c | 4 ++++ openair2/LAYER2/NR_MAC_gNB/main.c | 2 ++ openair2/LAYER2/NR_MAC_gNB/nr_mac_gNB.h | 4 ++++ 3 files changed, 10 insertions(+) diff --git a/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_ulsch.c b/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_ulsch.c index 692e1b681c..9fc8a60423 100644 --- a/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_ulsch.c +++ b/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_ulsch.c @@ -1316,8 +1316,11 @@ void handle_nr_srs_measurements(const module_id_t module_id, NR_UE_UL_BWP_t *current_BWP = &UE->current_UL_BWP; sched_ctrl->srs_feedback.sri = NR_SRS_SRI_0; + start_meas(&nr_mac->nr_srs_ri_computation_timer); nr_srs_ri_computation(&nr_srs_channel_iq_matrix, current_BWP, &sched_ctrl->srs_feedback.ul_ri); + stop_meas(&nr_mac->nr_srs_ri_computation_timer); + start_meas(&nr_mac->nr_srs_tpmi_computation_timer); sched_ctrl->srs_feedback.tpmi = nr_srs_tpmi_estimation(current_BWP->pusch_Config, current_BWP->transform_precoding, nr_srs_channel_iq_matrix.channel_matrix, @@ -1327,6 +1330,7 @@ void handle_nr_srs_measurements(const module_id_t module_id, nr_srs_channel_iq_matrix.prg_size, nr_srs_channel_iq_matrix.num_prgs, sched_ctrl->srs_feedback.ul_ri); + stop_meas(&nr_mac->nr_srs_tpmi_computation_timer); sprintf(stats->srs_stats, "UL-RI %d, TPMI %d", sched_ctrl->srs_feedback.ul_ri + 1, sched_ctrl->srs_feedback.tpmi); diff --git a/openair2/LAYER2/NR_MAC_gNB/main.c b/openair2/LAYER2/NR_MAC_gNB/main.c index 7fd559fdcd..3a6e73de20 100644 --- a/openair2/LAYER2/NR_MAC_gNB/main.c +++ b/openair2/LAYER2/NR_MAC_gNB/main.c @@ -69,6 +69,8 @@ void *nrmac_stats_thread(void *arg) { p += print_meas_log(&gNB->schedule_dlsch, "dlsch scheduler", NULL, NULL, p, end - p); p += print_meas_log(&gNB->rlc_data_req, "rlc_data_req", NULL, NULL, p, end - p); p += print_meas_log(&gNB->rlc_status_ind, "rlc_status_ind", NULL, NULL, p, end - p); + p += print_meas_log(&gNB->nr_srs_ri_computation_timer, "UL-RI computation time", NULL, NULL, p, end - p); + p += print_meas_log(&gNB->nr_srs_tpmi_computation_timer, "UL-TPMI computation time", NULL, NULL, p, end - p); fwrite(output, p - output, 1, file); fflush(file); sleep(1); diff --git a/openair2/LAYER2/NR_MAC_gNB/nr_mac_gNB.h b/openair2/LAYER2/NR_MAC_gNB/nr_mac_gNB.h index 4bec3664c8..92b701277d 100644 --- a/openair2/LAYER2/NR_MAC_gNB/nr_mac_gNB.h +++ b/openair2/LAYER2/NR_MAC_gNB/nr_mac_gNB.h @@ -780,6 +780,10 @@ typedef struct gNB_MAC_INST_s { time_stats_t rlc_data_req; /// processing time of rlc_status_ind time_stats_t rlc_status_ind; + /// processing time of nr_srs_ri_computation + time_stats_t nr_srs_ri_computation_timer; + /// processing time of nr_srs_tpmi_estimation + time_stats_t nr_srs_tpmi_computation_timer; /// processing time of eNB MCH scheduler time_stats_t schedule_mch; /// processing time of eNB ULSCH reception From 678768953792022fd589c4d0da5840a4758e715c Mon Sep 17 00:00:00 2001 From: rmagueta Date: Fri, 12 May 2023 15:18:00 +0100 Subject: [PATCH 02/47] Compute RI based on SRS up to 4 --- .../LAYER2/NR_MAC_gNB/gNB_scheduler_srs.c | 390 +++++++++++++++--- 1 file changed, 329 insertions(+), 61 deletions(-) diff --git a/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_srs.c b/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_srs.c index c384691e87..20da335e6c 100644 --- a/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_srs.c +++ b/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_srs.c @@ -32,6 +32,10 @@ #include "common/ran_context.h" #include "nfapi/oai_integration/vendor_ext.h" #include "common/utils/nr/nr_common.h" +#include +#include +#include +#include //#define SRS_DEBUG @@ -42,12 +46,112 @@ const uint16_t m_SRS[64] = { 4, 8, 12, 16, 16, 20, 24, 24, 28, 32, 36, 40, 48, 4 160, 160, 168, 176, 184, 192, 192, 192, 192, 208, 216, 224, 240, 240, 240, 240, 256, 256, 256, 264, 272, 272, 272 }; -static uint32_t max4(uint32_t a, uint32_t b, uint32_t c, uint32_t d) +#ifdef SRS_DEBUG +static void print128_number(const simde__m128i var) { - int x = max(a, b); - x = max(x, c); - x = max(x, d); - return x; + int32_t *var16 = (int32_t *)&var; + for (int i = 0; i < 4; i++) { + printf("%5d ", var16[i]); + } + printf("\n"); +} +#endif + +int most_frequent_ri(const int *arr, int n) +{ + int maxcount = 0; + int element_having_max_freq = -1; + for (int i = 0; i < n; i++) { + int count = 0; + for (int j = 0; j < n; j++) { + if (arr[i] == arr[j]) + count++; + } + if (count > maxcount) { + maxcount = count; + element_having_max_freq = arr[i]; + } + } + return element_having_max_freq; +} + +void matrix_rank_128bits(int row, int col, simde__m128i mat[4]) +{ + if ((row == 2 && col == 2) || (row == 4 && col == 2)) { + + int32_t *mat_k = (int32_t *)&mat[0]; + int32_t *mat_i = (int32_t *)&mat[1]; + + simde__m128 mult_128 = simde_mm_setr_ps((float)mat_i[0] / (float)mat_k[0], + (float)mat_i[0] / (float)mat_k[0], + (float)mat_i[2] / (float)mat_k[2], + (float)mat_i[2] / (float)mat_k[2]); + + simde__m128i mat_kj_128 = simde_mm_setr_epi32(mat_k[0], mat_k[1], mat_k[2], mat_k[3]); + simde__m128 multiplication = simde_mm_mul_ps(mult_128, simde_mm_cvtepi32_ps(mat_kj_128)); + mat[1] = simde_mm_sub_epi32(mat[1], simde_mm_cvtps_epi32(multiplication)); + + mat_k = (int32_t *)&mat[2]; + mat_i = (int32_t *)&mat[3]; + + mult_128 = simde_mm_setr_ps((float)mat_i[0] / (float)mat_k[0], + (float)mat_i[0] / (float)mat_k[0], + (float)mat_i[2] / (float)mat_k[2], + (float)mat_i[2] / (float)mat_k[2]); + + mat_kj_128 = simde_mm_setr_epi32(mat_k[0], mat_k[1], mat_k[2], mat_k[3]); + multiplication = simde_mm_mul_ps(mult_128, simde_mm_cvtepi32_ps(mat_kj_128)); + mat[3] = simde_mm_sub_epi32(mat[3], simde_mm_cvtps_epi32(multiplication)); + + } else if (row == 2 && col == 4) { + + int32_t *mat_k = (int32_t *)&mat[0]; + int32_t *mat_i = (int32_t *)&mat[1]; + + simde__m128 mult_128 = simde_mm_setr_ps((float)mat_i[0] / (float)mat_k[0], + (float)mat_i[0] / (float)mat_k[0], + (float)mat_i[0] / (float)mat_k[0], + (float)mat_i[0] / (float)mat_k[0]); + + simde__m128i mat_kj_128 = simde_mm_setr_epi32(mat_k[0], mat_k[1], mat_k[2], mat_k[3]); + simde__m128 multiplication = simde_mm_mul_ps(mult_128, simde_mm_cvtepi32_ps(mat_kj_128)); + mat[1] = simde_mm_sub_epi32(mat[1], simde_mm_cvtps_epi32(multiplication)); + + mat_k = (int32_t *)&mat[2]; + mat_i = (int32_t *)&mat[3]; + + mult_128 = simde_mm_setr_ps((float)mat_i[0] / (float)mat_k[0], + (float)mat_i[0] / (float)mat_k[0], + (float)mat_i[0] / (float)mat_k[0], + (float)mat_i[0] / (float)mat_k[0]); + + mat_kj_128 = simde_mm_setr_epi32(mat_k[0], mat_k[1], mat_k[2], mat_k[3]); + multiplication = simde_mm_mul_ps(mult_128, simde_mm_cvtepi32_ps(mat_kj_128)); + mat[3] = simde_mm_sub_epi32(mat[3], simde_mm_cvtps_epi32(multiplication)); + + } else if (row == 4 && col == 4) { + + for (int k = 0; k < col; k++) { + int32_t *mat_k = (int32_t *)&mat[k]; + + for (int i = k + 1; i < row; i++) { + int32_t *mat_i = (int32_t *)&mat[i]; + + float mult = (float)mat_i[k] / (float)mat_k[k]; + if (isnan(mult)) + mult = 0; + if (isinf(mult)) + mult = 0; + + simde__m128 mult_128 = simde_mm_set1_ps(mult); + simde__m128i mat_kj_128 = simde_mm_setr_epi32(mat_k[0], mat_k[1], mat_k[2], mat_k[3]); + simde__m128 multiplication = simde_mm_mul_ps(mult_128, simde_mm_cvtepi32_ps(mat_kj_128)); + mat[i] = simde_mm_sub_epi32(mat[i], simde_mm_cvtps_epi32(multiplication)); + } + } + } else { + AssertFatal(1 == 0, "matrix_rank_128bits() function is not implemented for row = %i and col = %i\n", row, col); + } } void nr_srs_ri_computation(const nfapi_nr_srs_normalized_channel_iq_matrix_t *nr_srs_normalized_channel_iq_matrix, @@ -57,12 +161,15 @@ void nr_srs_ri_computation(const nfapi_nr_srs_normalized_channel_iq_matrix_t *nr /* already mutex protected: held in handle_nr_srs_measurements() */ NR_SCHED_ENSURE_LOCKED(&RC.nrmac[0]->sched_lock); - // If the gNB or UE has 1 antenna, the rank is always 1, i.e., *ul_ri = 0. - // For 2x2 scenario, we compute the rank of channel. - // The computation for 2x4, 4x2, 4x4, ... scenarios are not implemented yet. In these cases, the function sets *ul_ri = 0, which is always a valid value. - if (!(nr_srs_normalized_channel_iq_matrix->num_gnb_antenna_elements == 2 && - nr_srs_normalized_channel_iq_matrix->num_ue_srs_ports == 2 && - current_BWP->pusch_Config && *current_BWP->pusch_Config->maxRank == 2)) { +#ifdef SRS_DEBUG + LOG_I(NR_MAC, "num_gnb_antenna_elements = %i\n", nr_srs_normalized_channel_iq_matrix->num_gnb_antenna_elements); + LOG_I(NR_MAC, "num_ue_srs_ports = %i\n", nr_srs_normalized_channel_iq_matrix->num_ue_srs_ports); +#endif + + if (nr_srs_normalized_channel_iq_matrix->num_gnb_antenna_elements == 1 || + nr_srs_normalized_channel_iq_matrix->num_ue_srs_ports == 1 || + current_BWP->pusch_Config == NULL || + (current_BWP->pusch_Config && *current_BWP->pusch_Config->maxRank == 1)) { *ul_ri = 0; return; } @@ -70,75 +177,236 @@ void nr_srs_ri_computation(const nfapi_nr_srs_normalized_channel_iq_matrix_t *nr const c16_t *ch = (c16_t *)nr_srs_normalized_channel_iq_matrix->channel_matrix; const uint16_t num_gnb_antenna_elements = nr_srs_normalized_channel_iq_matrix->num_gnb_antenna_elements; const uint16_t num_prgs = nr_srs_normalized_channel_iq_matrix->num_prgs; - const uint16_t base00_idx = 0 * num_gnb_antenna_elements * num_prgs + 0 * num_prgs; // Rx antenna 0, Tx port 0 - const uint16_t base01_idx = 1 * num_gnb_antenna_elements * num_prgs + 0 * num_prgs; // Rx antenna 0, Tx port 1 - const uint16_t base10_idx = 0 * num_gnb_antenna_elements * num_prgs + 1 * num_prgs; // Rx antenna 1, Tx port 0 - const uint16_t base11_idx = 1 * num_gnb_antenna_elements * num_prgs + 1 * num_prgs; // Rx antenna 1, Tx port 1 - const uint8_t bshift = 2; - const int16_t cond_dB_threshold = 5; - int count = 0; - for(int pI = 0; pI < num_prgs; pI++) { + int row = num_gnb_antenna_elements; + int col = nr_srs_normalized_channel_iq_matrix->num_ue_srs_ports; + simde__m128i mat_real128[4]; + simde__m128i mat_imag128[4]; + simde__m128i sum_matrix[4]; - /* Hh x H = - * | conjch00 conjch10 | x | ch00 ch01 | = | conjch00*ch00+conjch10*ch10 conjch00*ch01+conjch10*ch11 | - * | conjch01 conjch11 | | ch10 ch11 | | conjch01*ch00+conjch11*ch10 conjch01*ch01+conjch11*ch11 | - */ + if ((row == 2 && col == 2) || (row == 4 && col == 2)) { + int array_lim = num_prgs >> 2; + int antenna_rank[array_lim]; + int count = 0; - const c32_t ch00 = {ch[base00_idx + pI].r, ch[base00_idx + pI].i}; - const c32_t ch01 = {ch[base01_idx + pI].r, ch[base01_idx + pI].i}; - const c32_t ch10 = {ch[base10_idx + pI].r, ch[base10_idx + pI].i}; - const c32_t ch11 = {ch[base11_idx + pI].r, ch[base11_idx + pI].i}; + const uint16_t base00_idx = 0 * num_gnb_antenna_elements * num_prgs + 0 * num_prgs; // Rx antenna 0, Tx port 0 + const uint16_t base01_idx = 1 * num_gnb_antenna_elements * num_prgs + 0 * num_prgs; // Rx antenna 0, Tx port 1 + const uint16_t base10_idx = 0 * num_gnb_antenna_elements * num_prgs + 1 * num_prgs; // Rx antenna 1, Tx port 0 + const uint16_t base11_idx = 1 * num_gnb_antenna_elements * num_prgs + 1 * num_prgs; // Rx antenna 1, Tx port 1 - c16_t HhxH00 = {(int16_t)((ch00.r * ch00.r + ch00.i * ch00.i + ch10.r * ch10.r + ch10.i * ch10.i) >> bshift), - (int16_t)((ch00.r * ch00.i - ch00.i * ch00.r + ch10.r * ch10.i - ch10.i * ch10.r) >> bshift)}; + for (int pI = 0; pI < num_prgs; pI += 4) { + uint16_t pI00 = pI + base00_idx; + uint16_t pI10 = pI + base10_idx; + uint16_t pI01 = pI + base01_idx; + uint16_t pI11 = pI + base11_idx; + mat_real128[0] = simde_mm_setr_epi32(ch[pI00].r, ch[pI10].r, ch[pI00 + 1].r, ch[pI10 + 1].r); + mat_real128[1] = simde_mm_setr_epi32(ch[pI01].r, ch[pI11].r, ch[pI01 + 1].r, ch[pI11 + 1].r); + mat_real128[2] = simde_mm_setr_epi32(ch[pI00 + 2].r, ch[pI10 + 2].r, ch[pI00 + 3].r, ch[pI10 + 3].r); + mat_real128[3] = simde_mm_setr_epi32(ch[pI01 + 2].r, ch[pI11 + 2].r, ch[pI01 + 3].r, ch[pI11 + 3].r); + mat_imag128[0] = simde_mm_setr_epi32(ch[pI00].i, ch[pI10].i, ch[pI00 + 1].i, ch[pI10 + 1].i); + mat_imag128[1] = simde_mm_setr_epi32(ch[pI01].i, ch[pI11].i, ch[pI01 + 1].i, ch[pI11 + 1].i); + mat_imag128[2] = simde_mm_setr_epi32(ch[pI00 + 2].i, ch[pI10 + 2].i, ch[pI00 + 3].i, ch[pI10 + 3].i); + mat_imag128[3] = simde_mm_setr_epi32(ch[pI01 + 2].i, ch[pI11 + 2].i, ch[pI01 + 3].i, ch[pI11 + 3].i); - c16_t HhxH01 = {(int16_t)((ch00.r * ch01.r + ch00.i * ch01.i + ch10.r * ch11.r + ch10.i * ch11.i) >> bshift), - (int16_t)((ch00.r * ch01.i - ch00.i * ch01.r + ch10.r * ch11.i - ch10.i * ch11.r) >> bshift)}; + matrix_rank_128bits(row, col, mat_real128); + matrix_rank_128bits(row, col, mat_imag128); - c16_t HhxH10 = {(int16_t)((ch01.r * ch00.r + ch01.i * ch00.i + ch11.r * ch10.r + ch11.i * ch10.i) >> bshift), - (int16_t)((ch01.r * ch00.i - ch01.i * ch00.r + ch11.r * ch10.i - ch11.i * ch10.r) >> bshift)}; + sum_matrix[0] = simde_mm_add_epi32(mat_real128[0], mat_imag128[0]); + sum_matrix[1] = simde_mm_add_epi32(mat_real128[1], mat_imag128[1]); + sum_matrix[2] = simde_mm_add_epi32(mat_real128[2], mat_imag128[2]); + sum_matrix[3] = simde_mm_add_epi32(mat_real128[3], mat_imag128[3]); - c16_t HhxH11 = {(int16_t)((ch01.r * ch01.r + ch01.i * ch01.i + ch11.r * ch11.r + ch11.i * ch11.i) >> bshift), - (int16_t)((ch01.r * ch01.i - ch01.i * ch01.r + ch11.r * ch11.i - ch11.i * ch11.r) >> bshift)}; +#ifdef SRS_DEBUG + LOG_I(NR_MAC, "\nSum matrix\n"); + print128_number(sum_matrix[0]); + print128_number(sum_matrix[1]); + print128_number(sum_matrix[2]); + print128_number(sum_matrix[3]); +#endif - int8_t det_HhxH_dB = dB_fixed(HhxH00.r * HhxH11.r - HhxH00.i * HhxH11.i - HhxH01.r * HhxH10.r + HhxH01.i * HhxH10.i); + int count_pivots = 0; - int8_t norm_HhxH_2_dB = dB_fixed(max4(HhxH00.r*HhxH00.r + HhxH00.i*HhxH00.i, - HhxH01.r*HhxH01.r + HhxH01.i*HhxH01.i, - HhxH10.r*HhxH10.r + HhxH10.i*HhxH10.i, - HhxH11.r*HhxH11.r + HhxH11.i*HhxH11.i)); + int32_t *sum_matrix_i = (int32_t *)&sum_matrix[1]; + if (sum_matrix_i[1] != 0) + count_pivots++; + if (sum_matrix_i[3] != 0) + count_pivots++; - int8_t cond_db = norm_HhxH_2_dB - det_HhxH_dB; + sum_matrix_i = (int32_t *)&sum_matrix[3]; + if (sum_matrix_i[1] != 0) + count_pivots++; + if (sum_matrix_i[3] != 0) + count_pivots++; - if (cond_db < cond_dB_threshold) { + antenna_rank[count] = count_pivots / 4; + count++; + } + *ul_ri = most_frequent_ri(antenna_rank, array_lim); + + } else if (row == 2 && col == 4) { + + int array_lim = num_prgs >> 1; + int antenna_rank[array_lim]; + int count = 0; + + const uint16_t base00_idx = 0 * num_gnb_antenna_elements * num_prgs + 0 * num_prgs; // Rx antenna 0, Tx port 0 + const uint16_t base10_idx = 1 * num_gnb_antenna_elements * num_prgs + 0 * num_prgs; // Rx antenna 1, Tx port 0 + const uint16_t base20_idx = 2 * num_gnb_antenna_elements * num_prgs + 0 * num_prgs; // Rx antenna 2, Tx port 0 + const uint16_t base30_idx = 3 * num_gnb_antenna_elements * num_prgs + 0 * num_prgs; // Rx antenna 3, Tx port 0 + + const uint16_t base01_idx = 0 * num_gnb_antenna_elements * num_prgs + 1 * num_prgs; // Rx antenna 0, Tx port 1 + const uint16_t base11_idx = 1 * num_gnb_antenna_elements * num_prgs + 1 * num_prgs; // Rx antenna 1, Tx port 1 + const uint16_t base21_idx = 2 * num_gnb_antenna_elements * num_prgs + 1 * num_prgs; // Rx antenna 2, Tx port 1 + const uint16_t base31_idx = 3 * num_gnb_antenna_elements * num_prgs + 1 * num_prgs; // Rx antenna 3, Tx port 1 + + for (int pI = 0; pI < num_prgs; pI += 2) { + + mat_real128[0] = simde_mm_setr_epi32(ch[base00_idx + pI].r, + ch[base10_idx + pI].r, + ch[base20_idx + pI].r, + ch[base30_idx + pI].r); + mat_real128[1] = simde_mm_setr_epi32(ch[base01_idx + pI].r, + ch[base11_idx + pI].r, + ch[base21_idx + pI].r, + ch[base31_idx + pI].r); + mat_real128[2] = simde_mm_setr_epi32(ch[base00_idx + (pI + 1)].r, + ch[base10_idx + (pI + 1)].r, + ch[base20_idx + (pI + 1)].r, + ch[base30_idx + (pI + 1)].r); + mat_real128[3] = simde_mm_setr_epi32(ch[base01_idx + (pI + 1)].r, + ch[base11_idx + (pI + 1)].r, + ch[base21_idx + (pI + 1)].r, + ch[base31_idx + (pI + 1)].r); + + mat_imag128[0] = simde_mm_setr_epi32(ch[base00_idx + pI].i, + ch[base10_idx + pI].i, + ch[base20_idx + pI].i, + ch[base30_idx + pI].i); + mat_imag128[1] = simde_mm_setr_epi32(ch[base01_idx + pI].i, + ch[base11_idx + pI].i, + ch[base21_idx + pI].i, + ch[base31_idx + pI].i); + mat_imag128[2] = simde_mm_setr_epi32(ch[base00_idx + (pI + 1)].i, + ch[base10_idx + (pI + 1)].i, + ch[base20_idx + (pI + 1)].i, + ch[base30_idx + (pI + 1)].i); + mat_imag128[3] = simde_mm_setr_epi32(ch[base01_idx + (pI + 1)].i, + ch[base11_idx + (pI + 1)].i, + ch[base21_idx + (pI + 1)].i, + ch[base31_idx + (pI + 1)].i); + + matrix_rank_128bits(row, col, mat_real128); + matrix_rank_128bits(row, col, mat_imag128); + + sum_matrix[0] = simde_mm_add_epi32(mat_real128[0], mat_imag128[0]); + sum_matrix[1] = simde_mm_add_epi32(mat_real128[1], mat_imag128[1]); + sum_matrix[2] = simde_mm_add_epi32(mat_real128[2], mat_imag128[2]); + sum_matrix[3] = simde_mm_add_epi32(mat_real128[3], mat_imag128[3]); + +#ifdef SRS_DEBUG + LOG_I(NR_MAC, "\nSum matrix\n"); + print128_number(sum_matrix[0]); + print128_number(sum_matrix[1]); + print128_number(sum_matrix[2]); + print128_number(sum_matrix[3]); +#endif + + int count_pivots = 0; + + int32_t *sum_matrix_i = (int32_t *)&sum_matrix[1]; + if (sum_matrix_i[1] != 0) + count_pivots++; + if (sum_matrix_i[3] != 0) + count_pivots++; + + sum_matrix_i = (int32_t *)&sum_matrix[3]; + if (sum_matrix_i[1] != 0) + count_pivots++; + if (sum_matrix_i[3] != 0) + count_pivots++; + + antenna_rank[count] = count_pivots / 2; count++; - } else { - count--; } -#ifdef SRS_DEBUG - LOG_I(NR_MAC, "H00[%i] = %i + j(%i)\n", pI, ch[base00_idx+pI].r, ch[base00_idx+pI].i); - LOG_I(NR_MAC, "H01[%i] = %i + j(%i)\n", pI, ch[base01_idx+pI].r, ch[base01_idx+pI].i); - LOG_I(NR_MAC, "H10[%i] = %i + j(%i)\n", pI, ch[base10_idx+pI].r, ch[base10_idx+pI].i); - LOG_I(NR_MAC, "H11[%i] = %i + j(%i)\n", pI, ch[base11_idx+pI].r, ch[base11_idx+pI].i); - LOG_I(NR_MAC, "HhxH00[%i] = %i + j(%i)\n", pI, HhxH00.r, HhxH00.i); - LOG_I(NR_MAC, "HhxH01[%i] = %i + j(%i)\n", pI, HhxH01.r, HhxH01.i); - LOG_I(NR_MAC, "HhxH10[%i] = %i + j(%i)\n", pI, HhxH10.r, HhxH10.i); - LOG_I(NR_MAC, "HhxH11[%i] = %i + j(%i)\n", pI, HhxH11.r, HhxH11.i); - LOG_I(NR_MAC, "det_HhxH[%i] = %i\n", pI, det_HhxH_dB); - LOG_I(NR_MAC, "norm_HhxH_2_dB[%i] = %i\n", pI, norm_HhxH_2_dB); -#endif - } + int rr = most_frequent_ri(antenna_rank, array_lim); + if (rr == 0 || rr == 1) + *ul_ri = 0; + if (rr > 1) + *ul_ri = 1; - if (count > 0) { - *ul_ri = 1; - } + } else if (row == 4 && col == 4) { + + int antenna_rank[num_prgs]; + int count = 0; + + const uint16_t base00_idx = 0 * num_gnb_antenna_elements * num_prgs + 0 * num_prgs; // Rx antenna 0, Tx port 0 + const uint16_t base10_idx = 1 * num_gnb_antenna_elements * num_prgs + 0 * num_prgs; // Rx antenna 1, Tx port 0 + const uint16_t base20_idx = 2 * num_gnb_antenna_elements * num_prgs + 0 * num_prgs; // Rx antenna 2, Tx port 0 + const uint16_t base30_idx = 3 * num_gnb_antenna_elements * num_prgs + 0 * num_prgs; // Rx antenna 3, Tx port 0 + + const uint16_t base01_idx = 0 * num_gnb_antenna_elements * num_prgs + 1 * num_prgs; // Rx antenna 0, Tx port 1 + const uint16_t base11_idx = 1 * num_gnb_antenna_elements * num_prgs + 1 * num_prgs; // Rx antenna 1, Tx port 1 + const uint16_t base21_idx = 2 * num_gnb_antenna_elements * num_prgs + 1 * num_prgs; // Rx antenna 2, Tx port 1 + const uint16_t base31_idx = 3 * num_gnb_antenna_elements * num_prgs + 1 * num_prgs; // Rx antenna 3, Tx port 1 + + const uint16_t base02_idx = 0 * num_gnb_antenna_elements * num_prgs + 2 * num_prgs; // Rx antenna 0, Tx port 2 + const uint16_t base12_idx = 1 * num_gnb_antenna_elements * num_prgs + 2 * num_prgs; // Rx antenna 1, Tx port 2 + const uint16_t base22_idx = 2 * num_gnb_antenna_elements * num_prgs + 2 * num_prgs; // Rx antenna 2, Tx port 2 + const uint16_t base32_idx = 3 * num_gnb_antenna_elements * num_prgs + 2 * num_prgs; // Rx antenna 3, Tx port 2 + + const uint16_t base03_idx = 0 * num_gnb_antenna_elements * num_prgs + 3 * num_prgs; // Rx antenna 0, Tx port 3 + const uint16_t base13_idx = 1 * num_gnb_antenna_elements * num_prgs + 3 * num_prgs; // Rx antenna 1, Tx port 3 + const uint16_t base23_idx = 2 * num_gnb_antenna_elements * num_prgs + 3 * num_prgs; // Rx antenna 2, Tx port 3 + const uint16_t base33_idx = 3 * num_gnb_antenna_elements * num_prgs + 3 * num_prgs; // Rx antenna 3, Tx port 3 + + for (int pI = 0; pI < num_prgs; pI++) { + mat_real128[0] = simde_mm_setr_epi32(ch[base00_idx + pI].r, ch[base10_idx + pI].r, ch[base20_idx + pI].r, ch[base30_idx + pI].r); + mat_real128[1] = simde_mm_setr_epi32(ch[base01_idx + pI].r, ch[base11_idx + pI].r, ch[base21_idx + pI].r, ch[base31_idx + pI].r); + mat_real128[2] = simde_mm_setr_epi32(ch[base02_idx + pI].r, ch[base12_idx + pI].r, ch[base22_idx + pI].r, ch[base32_idx + pI].r); + mat_real128[3] = simde_mm_setr_epi32(ch[base03_idx + pI].r, ch[base13_idx + pI].r, ch[base23_idx + pI].r, ch[base33_idx + pI].r); + + mat_imag128[0] = simde_mm_setr_epi32(ch[base00_idx + pI].i, ch[base10_idx + pI].i, ch[base20_idx + pI].i, ch[base30_idx + pI].i); + mat_imag128[1] = simde_mm_setr_epi32(ch[base01_idx + pI].i, ch[base11_idx + pI].i, ch[base21_idx + pI].i, ch[base31_idx + pI].i); + mat_imag128[2] = simde_mm_setr_epi32(ch[base02_idx + pI].i, ch[base12_idx + pI].i, ch[base22_idx + pI].i, ch[base32_idx + pI].i); + mat_imag128[3] = simde_mm_setr_epi32(ch[base03_idx + pI].i, ch[base13_idx + pI].i, ch[base23_idx + pI].i, ch[base33_idx + pI].i); + + matrix_rank_128bits(row, col, mat_real128); + matrix_rank_128bits(row, col, mat_imag128); + + sum_matrix[0] = simde_mm_add_epi32(mat_real128[0], mat_imag128[0]); + sum_matrix[1] = simde_mm_add_epi32(mat_real128[1], mat_imag128[1]); + sum_matrix[2] = simde_mm_add_epi32(mat_real128[2], mat_imag128[2]); + sum_matrix[3] = simde_mm_add_epi32(mat_real128[3], mat_imag128[3]); #ifdef SRS_DEBUG - LOG_I(NR_MAC, "ul_ri = %i (count = %i)\n", (*ul_ri)+1, count); + LOG_I(NR_MAC, "\nSum matrix\n"); + print128_number(sum_matrix[0]); + print128_number(sum_matrix[1]); + print128_number(sum_matrix[2]); + print128_number(sum_matrix[3]); #endif + int count_pivots = 0; + for (int i = 0; i < row; i++) { + int32_t *sum_matrix_i = (int32_t *)&sum_matrix[i]; + + int found_piv = 0; + for (int j = 0; j < col; j++) { + if (sum_matrix_i[j] != 0 && found_piv == 0) { + count_pivots++; + found_piv = 1; + } + } + } + antenna_rank[count] = count_pivots; + count++; + } + *ul_ri = most_frequent_ri(antenna_rank, num_prgs) - 1; + + } else { + AssertFatal(1 == 0, "nr_srs_ri_computation() function is not implemented for row = %i and col = %i\n", row, col); + } } static void nr_configure_srs(nfapi_nr_srs_pdu_t *srs_pdu, From e5804c48d62ee07258a4d3d5cd47cd5e86e587e7 Mon Sep 17 00:00:00 2001 From: rmagueta Date: Fri, 12 May 2023 15:24:51 +0100 Subject: [PATCH 03/47] Add UE capability config file for 4 ports --- .../GENERIC-NR-5GC/CONF/uecap_ports4.xml | 862 ++++++++++++++++++ 1 file changed, 862 insertions(+) create mode 100644 targets/PROJECTS/GENERIC-NR-5GC/CONF/uecap_ports4.xml diff --git a/targets/PROJECTS/GENERIC-NR-5GC/CONF/uecap_ports4.xml b/targets/PROJECTS/GENERIC-NR-5GC/CONF/uecap_ports4.xml new file mode 100644 index 0000000000..bd267f4302 --- /dev/null +++ b/targets/PROJECTS/GENERIC-NR-5GC/CONF/uecap_ports4.xml @@ -0,0 +1,862 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 11 + + + + + 01 + + + + + + + + + 8 + 64 + + 4 + 32 + + + 2 + 2 + 0 + 2 + 2 + + 0 + 4 + + + + + + + + + + + + + + + + + + + + 78 + + + + + + + + + + 2 + 8 + + + + + + + + + + + + + + + + + + + 8 + 64 + + + + 8 + 32 + + + + 4 + 64 + + + + 2 + 64 + + + + 4 + + + + + 8 + 64 + + 4 + 32 + + + 2 + 2 + 0 + 2 + 2 + + 0 + 4 + + + 2 + 1 + 8 + 16 + + + + + + + + + + 0000000000 + + + 0001011111 + + + 0000000000 + + + + + + + 0000000000 + + + 0001011111 + + + 0000000000 + + + + + + + + + + + 1000000000000000 + + + + + + + 1000000000000000 + + + + + + + + + + + 78 + + + + + 0 + + + + + + 78 + + + + + + + + + + + + + + + 8 + 64 + + 8 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + + + + + + 2 + + + + + + 3 + + + + + + 4 + + + + + + 5 + + + + + + 6 + + + + + + 7 + + + + + + 8 + + + + + + 9 + + + + + + 10 + + + + + + 11 + + + + + + 12 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1 + + + + 6 + + 6 + + 2 + + + + + + 2 + + + + 6 + + 6 + + 2 + + + + + + 3 + + + + 6 + + 6 + + 2 + + + + + + 4 + + + + 6 + + 6 + + 2 + + + + + + 5 + + + + 6 + + 6 + + 2 + + + + + + 6 + + + + 6 + + 6 + + 2 + + + + + + 7 + + + + 6 + + 6 + + 2 + + + + + + 8 + + + + 6 + + 6 + + 2 + + + + + + 9 + + + + 6 + + 6 + + 2 + + + + + + 10 + + + + 6 + + 6 + + 2 + + + + + + 11 + + + + 6 + + 6 + + 2 + + + + + + 12 + + + + 6 + + 6 + + 2 + + + + + + 11 + + + + 6 + + 6 + + 2 + + + + + + + + + + + + + 1 + + + + + + + + + + + + 1 + + + + + + + + + + + 1 + + + + + + + + + + + 1 + + + + + + + + + + + 1 + + + + + + + + + + + 1 + + + + + + + + + + + 1 + + + + + + + + + + + 1 + + + + + + + + + + + 1 + + + + + + + + + + + 1 + + + + + + + + + + + + 1 + + + + + + + + + + + 1 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 2 + 2 + + + + + + + + + 7 + 38 + + + + + + + + + From 4de550f04080a7eec81e8553ef9cd8b1f021bb4a Mon Sep 17 00:00:00 2001 From: Laurent THOMAS Date: Tue, 19 Sep 2023 15:08:19 +0200 Subject: [PATCH 04/47] fix bug for IE cause in pdu session accept --- common/utils/LOG/log.c | 9 -- .../ESM/MSG/PduSessionEstablishmentAccept.c | 144 +++++++++--------- openair3/ocp-gtpu/gtp_itf.cpp | 2 +- 3 files changed, 69 insertions(+), 86 deletions(-) diff --git a/common/utils/LOG/log.c b/common/utils/LOG/log.c index 9d47256bb4..0a12c34230 100644 --- a/common/utils/LOG/log.c +++ b/common/utils/LOG/log.c @@ -855,15 +855,6 @@ void flush_mem_to_file(void) } } -const char logmem_log_level[NUM_LOG_LEVEL] = { - [OAILOG_ERR] = 'E', - [OAILOG_WARNING] = 'W', - [OAILOG_ANALYSIS] = 'A', - [OAILOG_INFO] = 'I', - [OAILOG_DEBUG] = 'D', - [OAILOG_TRACE] = 'T', -}; - static void log_output_memory(log_component_t *c, const char *file, const char *func, int line, int comp, int level, const char* format,va_list args) { //logRecord_mt(file,func,line, pthread_self(), comp, level, format, ##args) diff --git a/openair3/NAS/COMMON/ESM/MSG/PduSessionEstablishmentAccept.c b/openair3/NAS/COMMON/ESM/MSG/PduSessionEstablishmentAccept.c index 72dedb3f7a..99ea466e2e 100644 --- a/openair3/NAS/COMMON/ESM/MSG/PduSessionEstablishmentAccept.c +++ b/openair3/NAS/COMMON/ESM/MSG/PduSessionEstablishmentAccept.c @@ -27,46 +27,49 @@ extern char *baseNetAddress; +static uint16_t getShort(uint8_t *input) +{ + uint16_t tmp16; + memcpy(&tmp16, input, sizeof(tmp16)); + return htons(tmp16); +} + void capture_pdu_session_establishment_accept_msg(uint8_t *buffer, uint32_t msg_length) { - uint8_t offset = 0; security_protected_nas_5gs_msg_t sec_nas_hdr; security_protected_plain_nas_5gs_msg_t sec_nas_msg; pdu_session_establishment_accept_msg_t psea_msg; - sec_nas_hdr.epd = *(buffer + (offset++)); - sec_nas_hdr.sht = *(buffer + (offset++)); + uint8_t *curPtr = buffer; + sec_nas_hdr.epd = *curPtr++; + sec_nas_hdr.sht = *curPtr++; uint32_t tmp; - memcpy(&tmp, buffer + offset, sizeof(tmp)); + memcpy(&tmp, buffer, sizeof(tmp)); sec_nas_hdr.mac = htonl(tmp); - offset+=sizeof(sec_nas_hdr.mac); - sec_nas_hdr.sqn = *(buffer + (offset++)); - sec_nas_msg.epd = *(buffer + (offset++)); - sec_nas_msg.sht = *(buffer + (offset++)); - sec_nas_msg.msg_type = *(buffer + (offset++)); - sec_nas_msg.payload_type = *(buffer + (offset++)); - uint16_t tmp16; - memcpy(&tmp16, buffer + offset, sizeof(tmp16)); - sec_nas_msg.payload_len = htons(tmp16); - offset+=sizeof(sec_nas_msg.payload_len); + curPtr += sizeof(sec_nas_hdr.mac); + sec_nas_hdr.sqn = *curPtr++; + sec_nas_msg.epd = *curPtr++; + sec_nas_msg.sht = *curPtr++; + sec_nas_msg.msg_type = *curPtr++; + sec_nas_msg.payload_type = *curPtr++; + sec_nas_msg.payload_len = getShort(curPtr); + curPtr += sizeof(sec_nas_msg.payload_len); /* Mandatory Presence IEs */ - psea_msg.epd = *(buffer + (offset++)); - psea_msg.pdu_id = *(buffer + (offset++)); - psea_msg.pti = *(buffer + (offset++)); - psea_msg.msg_type = *(buffer + (offset++)); - psea_msg.pdu_type = *(buffer + offset) & 0x0f; - psea_msg.ssc_mode = (*(buffer + (offset++)) & 0xf0) >> 4; - memcpy(&tmp16, buffer + offset, sizeof(tmp16)); - psea_msg.qos_rules.length = htons(tmp16); - offset+=sizeof(psea_msg.qos_rules.length); + psea_msg.epd = *curPtr++; + psea_msg.pdu_id = *curPtr++; + psea_msg.pti = *curPtr++; + psea_msg.msg_type = *curPtr++; + psea_msg.pdu_type = *curPtr & 0x0f; + psea_msg.ssc_mode = (*curPtr++ & 0xf0) >> 4; + psea_msg.qos_rules.length = getShort(curPtr); + curPtr += sizeof(psea_msg.qos_rules.length); /* Supports the capture of only one QoS Rule, it should be changed for multiple QoS Rules */ qos_rule_t qos_rule; - qos_rule.id = *(buffer + (offset++)); - memcpy(&tmp16, buffer + offset, sizeof(tmp16)); - qos_rule.length = htons(tmp16); - offset+=sizeof(qos_rule.length); - qos_rule.oc = (*(buffer + offset) & 0xE0) >> 5; - qos_rule.dqr = (*(buffer + offset) & 0x10) >> 4; - qos_rule.nb_pf = *(buffer + (offset++)) & 0x0F; + qos_rule.id = *curPtr++; + qos_rule.length = getShort(curPtr); + curPtr += sizeof(qos_rule.length); + qos_rule.oc = (*(curPtr)&0xE0) >> 5; + qos_rule.dqr = (*(curPtr)&0x10) >> 4; + qos_rule.nb_pf = *curPtr++ & 0x0F; if(qos_rule.nb_pf) { packet_filter_t pf; @@ -74,40 +77,39 @@ void capture_pdu_session_establishment_accept_msg(uint8_t *buffer, uint32_t msg_ if(qos_rule.oc == ROC_CREATE_NEW_QOS_RULE || qos_rule.oc == ROC_MODIFY_QOS_RULE_ADD_PF || qos_rule.oc == ROC_MODIFY_QOS_RULE_REPLACE_PF) { - pf.pf_type.type_1.pf_dir = (*(buffer + offset) & 0x30) >> 4; - pf.pf_type.type_1.pf_id = *(buffer + offset++) & 0x0F; - pf.pf_type.type_1.length = *(buffer + offset++); - offset += (qos_rule.nb_pf * pf.pf_type.type_1.length); /* Ommit the Packet filter List */ + pf.pf_type.type_1.pf_dir = (*curPtr & 0x30) >> 4; + pf.pf_type.type_1.pf_id = *curPtr++ & 0x0F; + pf.pf_type.type_1.length = *curPtr++; + curPtr += (qos_rule.nb_pf * pf.pf_type.type_1.length); /* Ommit the Packet filter List */ } else if (qos_rule.oc == ROC_MODIFY_QOS_RULE_DELETE_PF) { - offset += qos_rule.nb_pf; + curPtr += qos_rule.nb_pf; } } - qos_rule.prcd = *(buffer + offset++); - qos_rule.qfi = *(buffer + offset++); - psea_msg.sess_ambr.length = *(buffer + offset++); - offset += psea_msg.sess_ambr.length; /* Ommit the Seassion-AMBR */ + qos_rule.prcd = *curPtr++; + qos_rule.qfi = *curPtr++; + psea_msg.sess_ambr.length = *curPtr++; + curPtr += psea_msg.sess_ambr.length; /* Ommit the Seassion-AMBR */ /* Optional Presence IEs */ - uint8_t psea_iei = *(buffer + offset++); - - while(offset < msg_length) { + while (curPtr < buffer + msg_length) { + uint8_t psea_iei = *curPtr++; switch (psea_iei) { case IEI_5GSM_CAUSE: /* Ommited */ LOG_T(NAS, "PDU SESSION ESTABLISHMENT ACCEPT - Received 5GSM Cause IEI\n"); - offset++; + curPtr++; break; case IEI_PDU_ADDRESS: LOG_T(NAS, "PDU SESSION ESTABLISHMENT ACCEPT - Received PDU Address IE\n"); - psea_msg.pdu_addr_ie.pdu_length = *(buffer + offset++); - psea_msg.pdu_addr_ie.pdu_type = *(buffer + offset++); + psea_msg.pdu_addr_ie.pdu_length = *curPtr++; + psea_msg.pdu_addr_ie.pdu_type = *curPtr++; if (psea_msg.pdu_addr_ie.pdu_type == PDU_SESSION_TYPE_IPV4) { - psea_msg.pdu_addr_ie.pdu_addr_oct1 = *(buffer + offset++); - psea_msg.pdu_addr_ie.pdu_addr_oct2 = *(buffer + offset++); - psea_msg.pdu_addr_ie.pdu_addr_oct3 = *(buffer + offset++); - psea_msg.pdu_addr_ie.pdu_addr_oct4 = *(buffer + offset++); + psea_msg.pdu_addr_ie.pdu_addr_oct1 = *curPtr++; + psea_msg.pdu_addr_ie.pdu_addr_oct2 = *curPtr++; + psea_msg.pdu_addr_ie.pdu_addr_oct3 = *curPtr++; + psea_msg.pdu_addr_ie.pdu_addr_oct4 = *curPtr++; nas_getparams(); sprintf(baseNetAddress, "%d.%d", psea_msg.pdu_addr_ie.pdu_addr_oct1, psea_msg.pdu_addr_ie.pdu_addr_oct2); nas_config(1, psea_msg.pdu_addr_ie.pdu_addr_oct3, psea_msg.pdu_addr_ie.pdu_addr_oct4, "oaitun_ue"); @@ -117,78 +119,68 @@ void capture_pdu_session_establishment_accept_msg(uint8_t *buffer, uint32_t msg_ psea_msg.pdu_addr_ie.pdu_addr_oct3, psea_msg.pdu_addr_ie.pdu_addr_oct4); } else { - offset += psea_msg.pdu_addr_ie.pdu_length; + curPtr += psea_msg.pdu_addr_ie.pdu_length; } - - psea_iei = *(buffer + offset++); break; case IEI_RQ_TIMER_VALUE: /* Ommited */ LOG_T(NAS, "PDU SESSION ESTABLISHMENT ACCEPT - Received RQ timer value IE\n"); - offset++; /* TS 24.008 10.5.7.3 */ - psea_iei = *(buffer + offset++); + curPtr++; /* TS 24.008 10.5.7.3 */ break; case IEI_SNSSAI: /* Ommited */ LOG_T(NAS, "PDU SESSION ESTABLISHMENT ACCEPT - Received S-NSSAI IE\n"); - uint8_t snssai_length = *(buffer + offset); - offset += (snssai_length + sizeof(snssai_length)); - psea_iei = *(buffer + offset++); + uint8_t snssai_length = *curPtr; + curPtr += (snssai_length + sizeof(snssai_length)); break; case IEI_ALWAYSON_PDU: /* Ommited */ LOG_T(NAS, "PDU SESSION ESTABLISHMENT ACCEPT - Received Always-on PDU Session indication IE\n"); - offset++; - psea_iei = *(buffer + offset++); + curPtr++; break; case IEI_MAPPED_EPS: /* Ommited */ LOG_T(NAS, "PDU SESSION ESTABLISHMENT ACCEPT - Received Mapped EPS bearer context IE\n"); - uint16_t mapped_eps_length = htons(*(uint16_t *)(buffer + offset)); - offset += mapped_eps_length; - psea_iei = *(buffer + offset++); + uint16_t mapped_eps_length = getShort(curPtr); + curPtr += mapped_eps_length; break; case IEI_EAP_MSG: /* Ommited */ LOG_T(NAS, "PDU SESSION ESTABLISHMENT ACCEPT - Received EAP message IE\n"); - uint16_t eap_length = htons(*(uint16_t *)(buffer + offset)); - offset += (eap_length + sizeof(eap_length)); - psea_iei = *(buffer + offset++); + uint16_t eap_length = getShort(curPtr); + curPtr += (eap_length + sizeof(eap_length)); break; case IEI_AUTH_QOS_DESC: /* Ommited */ LOG_T(NAS, "PDU SESSION ESTABLISHMENT ACCEPT - Received Authorized QoS flow descriptions IE\n"); - psea_msg.qos_fd_ie.length = htons(*(uint16_t *)(buffer + offset)); - offset += (psea_msg.qos_fd_ie.length + sizeof(psea_msg.qos_fd_ie.length)); - psea_iei = *(buffer + offset++); + psea_msg.qos_fd_ie.length = getShort(curPtr); + curPtr += (psea_msg.qos_fd_ie.length + sizeof(psea_msg.qos_fd_ie.length)); break; case IEI_EXT_CONF_OPT: /* Ommited */ LOG_T(NAS, "PDU SESSION ESTABLISHMENT ACCEPT - Received Extended protocol configuration options IE\n"); - psea_msg.ext_pp_ie.length = htons(*(uint16_t *)(buffer + offset)); - offset += (psea_msg.ext_pp_ie.length + sizeof(psea_msg.ext_pp_ie.length )); - psea_iei = *(buffer + offset++); + psea_msg.ext_pp_ie.length = getShort(curPtr); + curPtr += (psea_msg.ext_pp_ie.length + sizeof(psea_msg.ext_pp_ie.length)); break; case IEI_DNN: LOG_T(NAS, "PDU SESSION ESTABLISHMENT ACCEPT - Received DNN IE\n"); - psea_msg.dnn_ie.dnn_length = *(buffer + offset++); + psea_msg.dnn_ie.dnn_length = *curPtr++; char apn[APN_MAX_LEN]; if(psea_msg.dnn_ie.dnn_length <= APN_MAX_LEN && psea_msg.dnn_ie.dnn_length >= APN_MIN_LEN) { - for (int i = 0 ; i < psea_msg.dnn_ie.dnn_length ; ++i) - apn[i] = *(buffer + offset + i); + memcpy(apn, curPtr, psea_msg.dnn_ie.dnn_length); LOG_T(NAS, "PDU SESSION ESTABLISHMENT ACCEPT - APN: %s\n", apn); } else LOG_E(NAS, "PDU SESSION ESTABLISHMENT ACCEPT - DNN IE has invalid length\n"); - offset = msg_length; + curPtr = buffer + msg_length; // we force stop processing break; default: LOG_T(NAS, "PDU SESSION ESTABLISHMENT ACCEPT - Not known IE\n"); - offset = msg_length; + curPtr = buffer + msg_length; // we force stop processing break; } } diff --git a/openair3/ocp-gtpu/gtp_itf.cpp b/openair3/ocp-gtpu/gtp_itf.cpp index b1920b6522..ec1bde544a 100644 --- a/openair3/ocp-gtpu/gtp_itf.cpp +++ b/openair3/ocp-gtpu/gtp_itf.cpp @@ -935,7 +935,7 @@ static int Gtpv1uHandleError(int h, uint32_t msgBufLen, uint16_t peerPort, uint32_t peerIp) { - LOG_E(GTPU,"Hadle error to be dev\n"); + LOG_E(GTPU, "Handle error to be dev\n"); int rc = GTPNOK; return rc; } From c481aad0c8bd6c380aae432d3c59edd4c8784d55 Mon Sep 17 00:00:00 2001 From: Raphael Defosseux Date: Mon, 2 Oct 2023 13:26:26 +0200 Subject: [PATCH 05/47] chore(ci): all pipelines should have the MR ID and branch in the description Signed-off-by: Raphael Defosseux --- ci-scripts/Jenkinsfile-cluster | 7 ++++++ ci-scripts/Jenkinsfile-nrue | 7 ++++++ ci-scripts/Jenkinsfile-physim-deploy | 7 ++++++ ci-scripts/Jenkinsfile-tmp-full-ran | 7 ++++++ ci-scripts/Jenkinsfile-tmp-multi-enb | 7 ++++++ ci-scripts/Jenkinsfile-tmp-ran | 32 ++++++---------------------- 6 files changed, 42 insertions(+), 25 deletions(-) diff --git a/ci-scripts/Jenkinsfile-cluster b/ci-scripts/Jenkinsfile-cluster index 65774c3280..40e54a9839 100644 --- a/ci-scripts/Jenkinsfile-cluster +++ b/ci-scripts/Jenkinsfile-cluster @@ -67,6 +67,13 @@ pipeline { } stages { + stage("Build Init") { + steps { + // update the build name and description + buildName "${params.eNB_MR}" + buildDescription "Branch : ${params.eNB_Branch}" + } + } stage ('Verify Parameters') { steps { script { diff --git a/ci-scripts/Jenkinsfile-nrue b/ci-scripts/Jenkinsfile-nrue index da14750c3c..610e2867f0 100644 --- a/ci-scripts/Jenkinsfile-nrue +++ b/ci-scripts/Jenkinsfile-nrue @@ -61,6 +61,13 @@ pipeline { } stages { + stage("Build Init") { + steps { + // update the build name and description + buildName "${params.eNB_MR}" + buildDescription "Branch : ${params.eNB_Branch}" + } + } stage ('Verify Parameters') { steps { script { diff --git a/ci-scripts/Jenkinsfile-physim-deploy b/ci-scripts/Jenkinsfile-physim-deploy index dac812e922..c90b254242 100644 --- a/ci-scripts/Jenkinsfile-physim-deploy +++ b/ci-scripts/Jenkinsfile-physim-deploy @@ -61,6 +61,13 @@ pipeline { } stages { + stage("Build Init") { + steps { + // update the build name and description + buildName "${params.eNB_MR}" + buildDescription "Branch : ${params.eNB_Branch}" + } + } stage ('Verify Parameters') { steps { script { diff --git a/ci-scripts/Jenkinsfile-tmp-full-ran b/ci-scripts/Jenkinsfile-tmp-full-ran index 5ee06cc585..54a338d16d 100644 --- a/ci-scripts/Jenkinsfile-tmp-full-ran +++ b/ci-scripts/Jenkinsfile-tmp-full-ran @@ -66,6 +66,13 @@ pipeline { } stages { + stage("Build Init") { + steps { + // update the build name and description + buildName "${params.eNB_MR}" + buildDescription "Branch : ${params.eNB_Branch}" + } + } stage ("Verify Parameters") { steps { script { diff --git a/ci-scripts/Jenkinsfile-tmp-multi-enb b/ci-scripts/Jenkinsfile-tmp-multi-enb index 0a1b944c5f..74b04a5cb9 100644 --- a/ci-scripts/Jenkinsfile-tmp-multi-enb +++ b/ci-scripts/Jenkinsfile-tmp-multi-enb @@ -54,6 +54,13 @@ pipeline { lock(extra: lockResources) } stages { + stage("Build Init") { + steps { + // update the build name and description + buildName "${params.eNB_MR}" + buildDescription "Branch : ${params.eNB_Branch}" + } + } stage ("Verify Parameters") { steps { script { diff --git a/ci-scripts/Jenkinsfile-tmp-ran b/ci-scripts/Jenkinsfile-tmp-ran index cddd72e23b..cf9dce5e09 100644 --- a/ci-scripts/Jenkinsfile-tmp-ran +++ b/ci-scripts/Jenkinsfile-tmp-ran @@ -66,32 +66,14 @@ pipeline { ansiColor('xterm') lock(extra: lockResources) } - // the following parameter options are commented out so it shows the ones - // that you SHALL have to run the job. - // You can use them as template - /* - parameters { - //node-test parameters - string(name: 'pythonExecutor', defaultValue: 'nodea', description: 'Node where the pipeline - python scripts will be executed') - string(name: 'pythonTestXmlFile', defaultValue: 'enb_usrpB210_band7_50PRB.xml', description: 'Location of the Test XML to be run') - string(name: 'pipelineTestStageName', defaultValue: 'Test COTS-UE - OAI eNB - LTEBOX EPC', description: 'Naming of the Test Stage') - booleanParam(name: 'pipelineZipsConsoleLog', defaultValue: 'True', description: 'If true, the pipeline script retrieves the job console log, zips it and archives it as artifact') - string(name: 'lockResources', defaultValue: 'CI-Bench-1-Phones', description: 'Lockeable Resource to prevent multiple jobs to run simultaneously with the same resource') - - //eNB parameters - string(name: 'eNB_IPAddress', defaultValue: '192.168.XX.XX', description: 'IP Address of eNB') - credentials(name: 'eNB_Credentials', defaultValue: 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX', credentialType: "Username with password", required: true, description: 'Credentials for eNB') - string(name: 'eNB_SourceCodePath', defaultValue: '/tmp/CI-enb', description: 'Full path of eNB source code') - - //EPC parameters - string(name: 'EPC_IPAddress', defaultValue: '192.168.XX.XX', description: 'IP Address of EPC') - string(name: 'EPC_Type', defaultValue: 'ltebox', description: 'EPC type: OAI or ltebox') - credentials(name: 'EPC_Credentials', defaultValue: 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX', credentialType: "Username with password", required: true, description: 'Credentials for EPC') - string(name: 'EPC_SourceCodePath', defaultValue: '/tmp/CI-enb', description: 'Full path of EPC source code') - } - */ - stages { + stage("Build Init") { + steps { + // update the build name and description + buildName "${params.eNB_MR}" + buildDescription "Branch : ${params.eNB_Branch}" + } + } stage ("Verify Parameters") { steps { script { From 06e63f7ccab0a2334d2afb24155c18b765c02e12 Mon Sep 17 00:00:00 2001 From: Raphael Defosseux Date: Mon, 2 Oct 2023 13:27:05 +0200 Subject: [PATCH 06/47] chore(ci): report in the GitLab MR comment the list of failing test stages Signed-off-by: Raphael Defosseux --- ci-scripts/Jenkinsfile-GitLab-Container | 26 ++++++++++++++++++++++++- 1 file changed, 25 insertions(+), 1 deletion(-) diff --git a/ci-scripts/Jenkinsfile-GitLab-Container b/ci-scripts/Jenkinsfile-GitLab-Container index 2f94a3e318..ca3675912a 100644 --- a/ci-scripts/Jenkinsfile-GitLab-Container +++ b/ci-scripts/Jenkinsfile-GitLab-Container @@ -31,6 +31,9 @@ def do5Gtest = false // def gitCommitAuthorEmailAddr +// list of failing stages +def failingStages = '' + pipeline { agent { label nodeExecutor @@ -136,6 +139,7 @@ pipeline { failure { script { currentBuild.result = 'FAILURE' + failingStages += '\n * RAN-Ubuntu18-Image-Builder' } } } @@ -155,6 +159,7 @@ pipeline { failure { script { currentBuild.result = 'FAILURE' + failingStages += '\n * RAN-RHEL8-Cluster-Image-Builder' } } } @@ -174,6 +179,7 @@ pipeline { failure { script { currentBuild.result = 'FAILURE' + failingStages += '\n * RAN-cppcheck' } } } @@ -199,6 +205,7 @@ pipeline { failure { script { currentBuild.result = 'FAILURE' + failingStages += '\n * RAN-PhySim-Cluster' } } } @@ -219,6 +226,7 @@ pipeline { failure { script { currentBuild.result = 'FAILURE' + failingStages += '\n * RAN-RF-Sim-Test-4G' } } } @@ -239,6 +247,7 @@ pipeline { failure { script { currentBuild.result = 'FAILURE' + failingStages += '\n * RAN-RF-Sim-Test-5G' } } } @@ -259,6 +268,7 @@ pipeline { failure { script { currentBuild.result = 'FAILURE' + failingStages += '\n * RAN-L2-Sim-Test-4G' } } } @@ -279,6 +289,7 @@ pipeline { failure { script { currentBuild.result = 'FAILURE' + failingStages += '\n * RAN-L2-Sim-Test-5G' } } } @@ -299,6 +310,7 @@ pipeline { failure { script { currentBuild.result = 'FAILURE' + failingStages += '\n * RAN-LTE-FDD-LTEBOX-Container' } } } @@ -320,6 +332,7 @@ pipeline { failure { script { currentBuild.result = 'FAILURE' + failingStages += '\n * RAN-LTE-FDD-OAIUE-OAICN4G-Container' } } } @@ -340,6 +353,7 @@ pipeline { failure { script { currentBuild.result = 'FAILURE' + failingStages += '\n * RAN-LTE-TDD-LTEBOX-Container' } } } @@ -360,6 +374,7 @@ pipeline { failure { script { currentBuild.result = 'FAILURE' + failingStages += '\n * RAN-NSA-B200-Module-LTEBOX-Container' } } } @@ -380,6 +395,7 @@ pipeline { failure { script { currentBuild.result = 'FAILURE' + failingStages += '\n * RAN-SA-B200-Module-SABOX-Container' } } } @@ -400,6 +416,7 @@ pipeline { failure { script { currentBuild.result = 'FAILURE' + failingStages += '\n * RAN-gNB-N300-Timing-Phytest-LDPC' } } } @@ -420,6 +437,7 @@ pipeline { failure { script { currentBuild.result = 'FAILURE' + failingStages += '\n * RAN-LTE-TDD-2x2-Container' } } } @@ -440,6 +458,7 @@ pipeline { failure { script { currentBuild.result = 'FAILURE' + failingStages += '\n * RAN-SA-AW2S-CN5G' } } } @@ -460,6 +479,7 @@ pipeline { failure { script { currentBuild.result = 'FAILURE' + failingStages += '\n * RAN-Interop-F1' } } } @@ -480,6 +500,7 @@ pipeline { failure { script { currentBuild.result = 'FAILURE' + failingStages += '\n * OAI-CN5G-COTS-UE-Test' } } } @@ -500,6 +521,7 @@ pipeline { failure { script { currentBuild.result = 'FAILURE' + failingStages += '\n * RAN-SA-OAIUE-CN5G' } } } @@ -518,6 +540,7 @@ pipeline { script { echo "Push to Docker-Hub KO" currentBuild.result = 'FAILURE' + failingStages += '\n * RAN-DockerHub-Push' } } } @@ -541,7 +564,8 @@ pipeline { script { def message = "OAI " + JOB_NAME + " build (" + BUILD_ID + "): failed (" + BUILD_URL + ")" if ("MERGE".equals(env.gitlabActionType)) { - addGitLabMRComment comment: message + def fullMessage = message + '\n\nList of failing test stages:' + failingStages + addGitLabMRComment comment: fullMessage def message2 = message + " -- MergeRequest #" + env.gitlabMergeRequestIid + " (" + env.gitlabMergeRequestTitle + ")" sendSocialMediaMessage('ci-enb', 'danger', message2) } else { From f9ab9ca1375a02f9a1637f10c011b16f3eb4c09c Mon Sep 17 00:00:00 2001 From: Raphael Defosseux Date: Mon, 2 Oct 2023 14:08:11 +0200 Subject: [PATCH 07/47] chore(ci): the failing test-case bullet will directly point to the HTML report Signed-off-by: Raphael Defosseux --- ci-scripts/Jenkinsfile-GitLab-Container | 84 +++++++++++++------------ 1 file changed, 45 insertions(+), 39 deletions(-) diff --git a/ci-scripts/Jenkinsfile-GitLab-Container b/ci-scripts/Jenkinsfile-GitLab-Container index ca3675912a..c73edd576e 100644 --- a/ci-scripts/Jenkinsfile-GitLab-Container +++ b/ci-scripts/Jenkinsfile-GitLab-Container @@ -32,7 +32,7 @@ def do5Gtest = false def gitCommitAuthorEmailAddr // list of failing stages -def failingStages = '' +def failingStages = "" pipeline { agent { @@ -133,13 +133,13 @@ pipeline { post { always { script { - finalizeSlaveJob('RAN-Ubuntu18-Image-Builder') + testBullet = finalizeSlaveJob('RAN-Ubuntu18-Image-Builder') } } failure { script { currentBuild.result = 'FAILURE' - failingStages += '\n * RAN-Ubuntu18-Image-Builder' + failingStages += testBullet } } } @@ -153,13 +153,13 @@ pipeline { post { always { script { - finalizeSlaveJob('RAN-RHEL8-Cluster-Image-Builder') + testBullet = finalizeSlaveJob('RAN-RHEL8-Cluster-Image-Builder') } } failure { script { currentBuild.result = 'FAILURE' - failingStages += '\n * RAN-RHEL8-Cluster-Image-Builder' + failingStages += testBullet } } } @@ -173,13 +173,13 @@ pipeline { post { always { script { - finalizeSlaveJob('RAN-cppcheck') + testBullet = finalizeSlaveJob('RAN-cppcheck') } } failure { script { currentBuild.result = 'FAILURE' - failingStages += '\n * RAN-cppcheck' + failingStages += testBullet } } } @@ -199,13 +199,13 @@ pipeline { post { always { script { - finalizeSlaveJob('RAN-PhySim-Cluster') + testBullet = finalizeSlaveJob('RAN-PhySim-Cluster') } } failure { script { currentBuild.result = 'FAILURE' - failingStages += '\n * RAN-PhySim-Cluster' + failingStages += testBullet } } } @@ -220,13 +220,13 @@ pipeline { post { always { script { - finalizeSlaveJob('RAN-RF-Sim-Test-4G') + testBullet = finalizeSlaveJob('RAN-RF-Sim-Test-4G') } } failure { script { currentBuild.result = 'FAILURE' - failingStages += '\n * RAN-RF-Sim-Test-4G' + failingStages += testBullet } } } @@ -241,13 +241,13 @@ pipeline { post { always { script { - finalizeSlaveJob('RAN-RF-Sim-Test-5G') + testBullet = finalizeSlaveJob('RAN-RF-Sim-Test-5G') } } failure { script { currentBuild.result = 'FAILURE' - failingStages += '\n * RAN-RF-Sim-Test-5G' + failingStages += testBullet } } } @@ -262,13 +262,13 @@ pipeline { post { always { script { - finalizeSlaveJob('RAN-L2-Sim-Test-4G') + testBullet = finalizeSlaveJob('RAN-L2-Sim-Test-4G') } } failure { script { currentBuild.result = 'FAILURE' - failingStages += '\n * RAN-L2-Sim-Test-4G' + failingStages += testBullet } } } @@ -283,13 +283,13 @@ pipeline { post { always { script { - finalizeSlaveJob('RAN-L2-Sim-Test-5G') + testBullet = finalizeSlaveJob('RAN-L2-Sim-Test-5G') } } failure { script { currentBuild.result = 'FAILURE' - failingStages += '\n * RAN-L2-Sim-Test-5G' + failingStages += testBullet } } } @@ -304,13 +304,13 @@ pipeline { post { always { script { - finalizeSlaveJob('RAN-LTE-FDD-LTEBOX-Container') + testBullet = finalizeSlaveJob('RAN-LTE-FDD-LTEBOX-Container') } } failure { script { currentBuild.result = 'FAILURE' - failingStages += '\n * RAN-LTE-FDD-LTEBOX-Container' + failingStages += testBullet } } } @@ -326,13 +326,13 @@ pipeline { post { always { script { - finalizeSlaveJob('RAN-LTE-FDD-OAIUE-OAICN4G-Container') + testBullet = finalizeSlaveJob('RAN-LTE-FDD-OAIUE-OAICN4G-Container') } } failure { script { currentBuild.result = 'FAILURE' - failingStages += '\n * RAN-LTE-FDD-OAIUE-OAICN4G-Container' + failingStages += testBullet } } } @@ -347,13 +347,13 @@ pipeline { post { always { script { - finalizeSlaveJob('RAN-LTE-TDD-LTEBOX-Container') + testBullet = finalizeSlaveJob('RAN-LTE-TDD-LTEBOX-Container') } } failure { script { currentBuild.result = 'FAILURE' - failingStages += '\n * RAN-LTE-TDD-LTEBOX-Container' + failingStages += testBullet } } } @@ -368,13 +368,13 @@ pipeline { post { always { script { - finalizeSlaveJob('RAN-NSA-B200-Module-LTEBOX-Container') + testBullet = finalizeSlaveJob('RAN-NSA-B200-Module-LTEBOX-Container') } } failure { script { currentBuild.result = 'FAILURE' - failingStages += '\n * RAN-NSA-B200-Module-LTEBOX-Container' + failingStages += testBullet } } } @@ -389,13 +389,13 @@ pipeline { post { always { script { - finalizeSlaveJob('RAN-SA-B200-Module-SABOX-Container') + testBullet = finalizeSlaveJob('RAN-SA-B200-Module-SABOX-Container') } } failure { script { currentBuild.result = 'FAILURE' - failingStages += '\n * RAN-SA-B200-Module-SABOX-Container' + failingStages += testBullet } } } @@ -410,13 +410,13 @@ pipeline { post { always { script { - finalizeSlaveJob('RAN-gNB-N300-Timing-Phytest-LDPC') + testBullet = finalizeSlaveJob('RAN-gNB-N300-Timing-Phytest-LDPC') } } failure { script { currentBuild.result = 'FAILURE' - failingStages += '\n * RAN-gNB-N300-Timing-Phytest-LDPC' + failingStages += testBullet } } } @@ -431,13 +431,13 @@ pipeline { post { always { script { - finalizeSlaveJob('RAN-LTE-TDD-2x2-Container') + testBullet = finalizeSlaveJob('RAN-LTE-TDD-2x2-Container') } } failure { script { currentBuild.result = 'FAILURE' - failingStages += '\n * RAN-LTE-TDD-2x2-Container' + failingStages += testBullet } } } @@ -452,13 +452,13 @@ pipeline { post { always { script { - finalizeSlaveJob('RAN-SA-AW2S-CN5G') + testBullet = finalizeSlaveJob('RAN-SA-AW2S-CN5G') } } failure { script { currentBuild.result = 'FAILURE' - failingStages += '\n * RAN-SA-AW2S-CN5G' + failingStages += testBullet } } } @@ -473,13 +473,13 @@ pipeline { post { always { script { - finalizeSlaveJob('RAN-Interop-F1') + testBullet = finalizeSlaveJob('RAN-Interop-F1') } } failure { script { currentBuild.result = 'FAILURE' - failingStages += '\n * RAN-Interop-F1' + failingStages += testBullet } } } @@ -494,13 +494,13 @@ pipeline { post { always { script { - finalizeSlaveJob('OAI-CN5G-COTS-UE-Test') + testBullet = finalizeSlaveJob('OAI-CN5G-COTS-UE-Test') } } failure { script { currentBuild.result = 'FAILURE' - failingStages += '\n * OAI-CN5G-COTS-UE-Test' + failingStages += testBullet } } } @@ -515,13 +515,13 @@ pipeline { post { always { script { - finalizeSlaveJob('RAN-SA-OAIUE-CN5G') + testBullet = finalizeSlaveJob('RAN-SA-OAIUE-CN5G') } } failure { script { currentBuild.result = 'FAILURE' - failingStages += '\n * RAN-SA-OAIUE-CN5G' + failingStages += testBullet } } } @@ -675,6 +675,7 @@ def finalizeSlaveJob(jobName) { } else { fileName = "test_results-${jobName}.html" } + artifactUrl = BUILD_URL if (!fileExists(fileName)) { copyArtifacts(projectName: jobName, filter: 'test_results*.html', @@ -682,8 +683,13 @@ def finalizeSlaveJob(jobName) { if (fileExists(fileName)) { sh "sed -i -e 's#TEMPLATE_BUILD_TIME#${JOB_TIMESTAMP}#' ${fileName}" archiveArtifacts artifacts: fileName + // BUILD_URL is like http://server:port/jenkins/job/foo/15/ + // no need to add a prefixed '/' + artifactUrl += 'artifact/' + fileName } } + artifactUrl = "\n * [${jobName}](${artifactUrl})" + return artifactUrl } // Abstraction function to send social media messages: From c603bcc1467028a67b7065ab501a37d72111d9a7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?R=C3=BAben=20Soares=20da=20Silva?= Date: Tue, 3 Oct 2023 13:36:15 +0100 Subject: [PATCH 08/47] Add bwp_size and bwp_start fields to struct fapi_nr_dl_config_csirs_pdu_rel15_t, for usage in the UE Fill bwp_size and bwp_start fields with values from BWP. --- nfapi/open-nFAPI/nfapi/public_inc/fapi_nr_ue_interface.h | 2 ++ openair2/LAYER2/NR_MAC_UE/nr_ue_scheduler.c | 2 ++ openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_primitives.c | 3 ++- 3 files changed, 6 insertions(+), 1 deletion(-) diff --git a/nfapi/open-nFAPI/nfapi/public_inc/fapi_nr_ue_interface.h b/nfapi/open-nFAPI/nfapi/public_inc/fapi_nr_ue_interface.h index 3dc6e930b7..2ac6dd4429 100644 --- a/nfapi/open-nFAPI/nfapi/public_inc/fapi_nr_ue_interface.h +++ b/nfapi/open-nFAPI/nfapi/public_inc/fapi_nr_ue_interface.h @@ -500,6 +500,8 @@ typedef struct { typedef struct { + uint16_t bwp_size; // Needed for SCF222 10.02 + uint16_t bwp_start; // Needed for SCF222 10.02 uint8_t subcarrier_spacing; // subcarrierSpacing [3GPP TS 38.211, sec 4.2], Value:0->4 uint8_t cyclic_prefix; // Cyclic prefix type [3GPP TS 38.211, sec 4.2], 0: Normal; 1: Extended uint16_t start_rb; // PRB where this CSI resource starts related to common resource block #0 (CRB#0). Only multiples of 4 are allowed. [3GPP TS 38.331, sec 6.3.2 parameter CSIFrequencyOccupation], Value: 0 ->274 diff --git a/openair2/LAYER2/NR_MAC_UE/nr_ue_scheduler.c b/openair2/LAYER2/NR_MAC_UE/nr_ue_scheduler.c index e2548fc7b1..86cf6ff281 100644 --- a/openair2/LAYER2/NR_MAC_UE/nr_ue_scheduler.c +++ b/openair2/LAYER2/NR_MAC_UE/nr_ue_scheduler.c @@ -2308,6 +2308,8 @@ void nr_schedule_csirs_reception(NR_UE_MAC_INST_t *mac, int frame, int slot) { continue; LOG_D(MAC,"Scheduling reception of CSI-RS in frame %d slot %d\n", frame, slot); fapi_nr_dl_config_csirs_pdu_rel15_t *csirs_config_pdu = &dl_config->dl_config_list[dl_config->number_pdus].csirs_config_pdu.csirs_config_rel15; + csirs_config_pdu->bwp_size = bwp_size; + csirs_config_pdu->bwp_start = bwp_start; csirs_config_pdu->measurement_bitmap = set_csirs_measurement_bitmap(csi_measconfig, csi_res_id); NR_CSI_RS_ResourceMapping_t resourceMapping = nzpcsi->resourceMapping; csirs_config_pdu->subcarrier_spacing = mu; diff --git a/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_primitives.c b/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_primitives.c index b9bb149310..ce465438a6 100644 --- a/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_primitives.c +++ b/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_primitives.c @@ -2570,7 +2570,8 @@ void nr_csirs_scheduling(int Mod_idP, frame_t frame, sub_frame_t slot, int n_slo dl_tti_csirs_pdu->PDUSize = (uint8_t)(2+sizeof(nfapi_nr_dl_tti_csi_rs_pdu)); nfapi_nr_dl_tti_csi_rs_pdu_rel15_t *csirs_pdu_rel15 = &dl_tti_csirs_pdu->csi_rs_pdu.csi_rs_pdu_rel15; - + csirs_pdu_rel15->bwp_size = dl_bwp->BWPSize; + csirs_pdu_rel15->bwp_start = dl_bwp->BWPStart; csirs_pdu_rel15->subcarrier_spacing = dl_bwp->scs; if (dl_bwp->cyclicprefix) csirs_pdu_rel15->cyclic_prefix = *dl_bwp->cyclicprefix; From 313419180f4af2da052c2ba0ec3b3b20229df2e8 Mon Sep 17 00:00:00 2001 From: rmagueta Date: Thu, 14 Sep 2023 15:54:06 +0100 Subject: [PATCH 09/47] PUCCH power computation in a different way --- openair1/PHY/NR_TRANSPORT/pucch_rx.c | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/openair1/PHY/NR_TRANSPORT/pucch_rx.c b/openair1/PHY/NR_TRANSPORT/pucch_rx.c index de3555bf29..84232ea140 100644 --- a/openair1/PHY/NR_TRANSPORT/pucch_rx.c +++ b/openair1/PHY/NR_TRANSPORT/pucch_rx.c @@ -256,6 +256,7 @@ void nr_decode_pucch0(PHY_VARS_gNB *gNB, int32_t rp[frame_parms->nb_antennas_rx][pucch_pdu->nr_of_symbols][nb_re_pucch]; memset(rp, 0, sizeof(rp)); int32_t *tmp_rp = NULL; + int signal_energy = 0; for (int l=0; lnr_of_symbols; l++) { uint8_t l2 = l + pucch_pdu->start_symbol_index; @@ -286,9 +287,13 @@ void nr_decode_pucch0(PHY_VARS_gNB *gNB, #endif } + signal_energy += signal_energy_nodc((int32_t *)r, nb_re_pucch); } } + signal_energy /= (pucch_pdu->nr_of_symbols * frame_parms->nb_antennas_rx); + int pucch_power_dBtimes10 = 10 * dB_fixed(signal_energy); + //int32_t no_corr = 0; int seq_index = 0; int64_t temp; @@ -377,7 +382,7 @@ void nr_decode_pucch0(PHY_VARS_gNB *gNB, int SNRtimes10,sigenergy=0; for (int aa=0;aanb_antennas_rx;aa++) sigenergy += signal_energy_nodc(rp[aa][0],12); - SNRtimes10 = xrtmag_dBtimes10-(10*max_n0); + SNRtimes10 = pucch_power_dBtimes10 - (10 * max_n0); int cqi; if (SNRtimes10 < -640) cqi=0; else if (SNRtimes10 > 635) cqi=255; @@ -421,7 +426,7 @@ void nr_decode_pucch0(PHY_VARS_gNB *gNB, uci_pdu->harq.harq_confidence_level = no_conf; uci_pdu->harq.harq_list[0].harq_value = !(index&0x01); LOG_D(PHY, - "[DLSCH/PDSCH/PUCCH] %d.%d HARQ %s with confidence level %s xrt_mag %d xrt_mag_next %d n0 %d (%d,%d) pucch0_thres %d, " + "[DLSCH/PDSCH/PUCCH] %d.%d HARQ %s with confidence level %s xrt_mag %d xrt_mag_next %d pucch_power_dBtimes10 %d n0 %d (%d,%d) pucch0_thres %d, " "cqi %d, SNRtimes10 %d, energy %f\n", frame, slot, @@ -429,6 +434,7 @@ void nr_decode_pucch0(PHY_VARS_gNB *gNB, uci_pdu->harq.harq_confidence_level == 0 ? "good" : "bad", xrtmag_dBtimes10, xrtmag_next_dBtimes10, + pucch_power_dBtimes10, max_n0, uci_stats->pucch0_n00, uci_stats->pucch0_n01, @@ -454,7 +460,7 @@ void nr_decode_pucch0(PHY_VARS_gNB *gNB, uci_pdu->harq.harq_list[1].harq_value = !(index&0x01); uci_pdu->harq.harq_list[0].harq_value = !((index>>1)&0x01); LOG_D(PHY, - "[DLSCH/PDSCH/PUCCH] %d.%d HARQ values (%s, %s) with confidence level %s, xrt_mag %d xrt_mag_next %d n0 %d (%d,%d) " + "[DLSCH/PDSCH/PUCCH] %d.%d HARQ values (%s, %s) with confidence level %s, xrt_mag %d xrt_mag_next %d pucch_power_dBtimes10 %d n0 %d (%d,%d) " "pucch0_thres %d, cqi %d, SNRtimes10 %d\n", frame, slot, @@ -463,6 +469,7 @@ void nr_decode_pucch0(PHY_VARS_gNB *gNB, uci_pdu->harq.harq_confidence_level == 0 ? "good" : "bad", xrtmag_dBtimes10, xrtmag_next_dBtimes10, + pucch_power_dBtimes10, max_n0, uci_stats->pucch0_n00, uci_stats->pucch0_n01, From a7af689d5029baa0db728b33845790bae7362144 Mon Sep 17 00:00:00 2001 From: Quency Date: Wed, 12 Jul 2023 15:49:25 +0200 Subject: [PATCH 10/47] feat / MIMO: Use 128/256 SIMDe for ARM64/x86 --- .../NR_TRANSPORT/nr_ulsch_llr_computation.c | 3450 ++++++++++++++++- 1 file changed, 3356 insertions(+), 94 deletions(-) diff --git a/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c b/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c index 1649f57878..d8fe9c1048 100644 --- a/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c +++ b/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c @@ -35,6 +35,9 @@ #include "PHY/sse_intrin.h" #include "PHY/impl_defs_top.h" +#ifdef __aarch64__ +#define USE_128BIT +#endif //---------------------------------------------------------------------------------------------- @@ -258,6 +261,7 @@ void nr_ulsch_compute_llr(int32_t *rxdataF_comp, */ void nr_ulsch_qpsk_qpsk(c16_t *stream0_in, c16_t *stream1_in, c16_t *stream0_out, c16_t *rho01, uint32_t length) { +#ifdef USE_128BIT simde__m128i *rho01_128i = (simde__m128i *)rho01; simde__m128i *stream0_128i_in = (simde__m128i *)stream0_in; simde__m128i *stream1_128i_in = (simde__m128i *)stream1_in; @@ -406,20 +410,241 @@ void nr_ulsch_qpsk_qpsk(c16_t *stream0_in, c16_t *stream1_in, c16_t *stream0_out simde_mm_storeu_si128(&stream0_128i_out[i + 1], simde_mm_unpackhi_epi16(y0r, y0i)); } } +#else + + simde__m256i *rho01_256i = (simde__m256i *)rho01; + simde__m256i *stream0_256i_in = (simde__m256i *)stream0_in; + simde__m256i *stream1_256i_in = (simde__m256i *)stream1_in; + simde__m256i *stream0_256i_out = (simde__m256i *)stream0_out; + simde__m256i ONE_OVER_2_SQRT_2 = simde_mm256_set1_epi16(23170); // round(2 ^ 16 / (2 * sqrt(2))) + + // In each iteration, we take 16 complex symbols + for (int i = 0; i < length >> 3; i += 2) { + + /// Compute real and imaginary parts of MF output for stream 0 (desired stream) + simde__m256i y0r, y0i; + simde_mm256_separate_real_imag_parts(&y0r, &y0i, stream0_256i_in[i], stream0_256i_in[i + 1]); + simde__m256i y0r_over2 = simde_mm256_mulhi_epi16(y0r, ONE_OVER_2_SQRT_2); + y0r_over2 = simde_mm256_slli_epi16(y0r_over2, 1); // y0r_over2 = Re(y0) / sqrt(2) + simde__m256i y0i_over2 = simde_mm256_mulhi_epi16(y0i, ONE_OVER_2_SQRT_2); + y0i_over2 = simde_mm256_slli_epi16(y0i_over2, 1); // y0i_over2 = Im(y0) / sqrt(2) + + /// Compute real and imaginary parts of MF output for stream 1 (interference stream) + simde__m256i y1r_over2, y1i_over2; + simde_mm256_separate_real_imag_parts(&y1r_over2, &y1i_over2, stream1_256i_in[i], stream1_256i_in[i + 1]); + y1r_over2 = simde_mm256_srai_epi16(y1r_over2, 1); // y1r_over2 = Re(y1) / 2 + y1i_over2 = simde_mm256_srai_epi16(y1i_over2, 1); // y1i_over2 = Im(y1) / 2 + + /// Get real and imaginary parts of rho + simde__m256i rhor, rhoi; + simde_mm256_separate_real_imag_parts(&rhor, &rhoi, rho01_256i[i], rho01_256i[i + 1]); + + /// Compute |psi_r| and |psi_i| + + // psi_r = rhor * xR + rhoi * xI + // psi_i = rhor * xI - rhoi * xR + + // Put (rho_r + rho_i)/(2*sqrt(2)) in rho_p + // rhor * xR + rhoi * xI --> xR = 1/sqrt(2) and xI = 1/sqrt(2) + // rhor * xI - rhoi * xR --> xR = -1/sqrt(2) and xI = 1/sqrt(2) + simde__m256i rho_p = simde_mm256_adds_epi16(rhor, rhoi); // rho_p = Re(rho) + Im(rho) + rho_p = simde_mm256_mulhi_epi16(rho_p, ONE_OVER_2_SQRT_2); // rho_p = rho_p / (2*sqrt(2)) + + // Put (rho_r - rho_i)/(2*sqrt(2)) in rho_m + // rhor * xR + rhoi * xI --> xR = 1/sqrt(2) and xI = -1/sqrt(2) + // rhor * xI - rhoi * xR --> xR = 1/sqrt(2) and xI = 1/sqrt(2) + simde__m256i rho_m = simde_mm256_subs_epi16(rhor, rhoi); // rho_m = Re(rho) - Im(rho) + rho_m = simde_mm256_mulhi_epi16(rho_m, ONE_OVER_2_SQRT_2); // rho_m = rho_m / (2*sqrt(2)) + + // xR = 1/sqrt(2) and xI = 1/sqrt(2) + simde__m256i abs_psi_rpm = simde_mm256_subs_epi16(rho_p, y1r_over2); // psi_rpm = rho_p - y1r/2 + abs_psi_rpm = simde_mm256_abs_epi16(abs_psi_rpm); // abs_psi_rpm = |psi_rpm| + + // xR = 1/sqrt(2) and xI = 1/sqrt(2) + simde__m256i abs_psi_imm = simde_mm256_subs_epi16(rho_m, y1i_over2); // psi_imm = rho_m - y1i/2 + abs_psi_imm = simde_mm256_abs_epi16(abs_psi_imm); // abs_psi_imm = |psi_imm| + + // xR = 1/sqrt(2) and xI = -1/sqrt(2) + simde__m256i abs_psi_rmm = simde_mm256_subs_epi16(rho_m, y1r_over2); // psi_rmm = rho_m - y1r/2 + abs_psi_rmm = simde_mm256_abs_epi16(abs_psi_rmm); // abs_psi_rmm = |psi_rmm| + + // xR = -1/sqrt(2) and xI = 1/sqrt(2) + simde__m256i abs_psi_ipm = simde_mm256_subs_epi16(rho_p, y1i_over2); // psi_ipm = rho_p - y1i/2 + abs_psi_ipm = simde_mm256_abs_epi16(abs_psi_ipm); // abs_psi_ipm = |psi_ipm| + + // xR = -1/sqrt(2) and xI = -1/sqrt(2) + simde__m256i abs_psi_rpp = simde_mm256_adds_epi16(rho_p, y1r_over2); // psi_rpp = rho_p + y1r/2 + abs_psi_rpp = simde_mm256_abs_epi16(abs_psi_rpp); // abs_psi_rpp = |psi_rpp| + + // xR = -1/sqrt(2) and xI = -1/sqrt(2) + simde__m256i abs_psi_imp = simde_mm256_adds_epi16(rho_m, y1i_over2); // psi_imp = rho_m + y1i/2 + abs_psi_imp = simde_mm256_abs_epi16(abs_psi_imp); // abs_psi_imp = |psi_imp| + + // xR = -1/sqrt(2) and xI = 1/sqrt(2) + simde__m256i abs_psi_rmp = simde_mm256_adds_epi16(rho_m, y1r_over2); // psi_rmp = rho_m + y1r/2 + abs_psi_rmp = simde_mm256_abs_epi16(abs_psi_rmp); // abs_psi_rmp = |psi_rmp| + + // xR = 1/sqrt(2) and xI = -1/sqrt(2) + simde__m256i abs_psi_ipp = simde_mm256_adds_epi16(rho_p, y1i_over2); // psi_ipm = rho_p + y1i/2 + abs_psi_ipp = simde_mm256_abs_epi16(abs_psi_ipp); // abs_psi_ipp = |psi_ipm| + + /// Compute bit metrics (lambda) + + // lambda = max { |psi_r - y1r| * |x2R| + |psi_i - y1i| * |x2I| + y0r * xR + y0i * xI} + + // xR = 1/sqrt(2) and xI = 1/sqrt(2) + // For numerator: bit_met_num_re_p = abs_psi_rpm + abs_psi_imm + y0r/sqrt(2) + y0i/sqrt(2) + simde__m256i bit_met_num_re_p = simde_mm256_adds_epi16(abs_psi_rpm, abs_psi_imm); + bit_met_num_re_p = simde_mm256_adds_epi16(bit_met_num_re_p, y0r_over2); + bit_met_num_re_p = simde_mm256_adds_epi16(bit_met_num_re_p, y0i_over2); + + // xR = 1/sqrt(2) and xI = -1/sqrt(2) + // For numerator: bit_met_num_re_m = abs_psi_rmm + abs_psi_ipp + y0r/sqrt(2) - y0i/sqrt(2) + simde__m256i bit_met_num_re_m = simde_mm256_adds_epi16(abs_psi_rmm, abs_psi_ipp); + bit_met_num_re_m = simde_mm256_adds_epi16(bit_met_num_re_m, y0r_over2); + bit_met_num_re_m = simde_mm256_subs_epi16(bit_met_num_re_m, y0i_over2); + + // xR = -1/sqrt(2) and xI = 1/sqrt(2) + // For denominator: bit_met_den_re_p = abs_psi_rmp + abs_psi_ipm - y0r/sqrt(2) + y0i/sqrt(2) + simde__m256i bit_met_den_re_p = simde_mm256_adds_epi16(abs_psi_rmp, abs_psi_ipm); + bit_met_den_re_p = simde_mm256_subs_epi16(bit_met_den_re_p, y0r_over2); + bit_met_den_re_p = simde_mm256_adds_epi16(bit_met_den_re_p, y0i_over2); + + // xR = -1/sqrt(2) and xI = -1/sqrt(2) + // For denominator: bit_met_den_re_m = abs_psi_rpp + abs_psi_imp - y0r/sqrt(2) - y0i/sqrt(2) + simde__m256i bit_met_den_re_m = simde_mm256_adds_epi16(abs_psi_rpp, abs_psi_imp); + bit_met_den_re_m = simde_mm256_subs_epi16(bit_met_den_re_m, y0r_over2); + bit_met_den_re_m = simde_mm256_subs_epi16(bit_met_den_re_m, y0i_over2); + + // xR = 1/sqrt(2) and xI = 1/sqrt(2) + // For numerator: bit_met_num_im_p = abs_psi_rpm + abs_psi_imm + y0r/sqrt(2) + y0i/sqrt(2) + simde__m256i bit_met_num_im_p = simde_mm256_adds_epi16(abs_psi_rpm, abs_psi_imm); + bit_met_num_im_p = simde_mm256_adds_epi16(bit_met_num_im_p, y0r_over2); + bit_met_num_im_p = simde_mm256_adds_epi16(bit_met_num_im_p, y0i_over2); + + // xR = -1/sqrt(2) and xI = 1/sqrt(2) + // For numerator: bit_met_num_im_m = abs_psi_rmp + abs_psi_ipm - y0r/sqrt(2) + y0i/sqrt(2) + simde__m256i bit_met_num_im_m = simde_mm256_adds_epi16(abs_psi_rmp, abs_psi_ipm); + bit_met_num_im_m = simde_mm256_subs_epi16(bit_met_num_im_m, y0r_over2); + bit_met_num_im_m = simde_mm256_adds_epi16(bit_met_num_im_m, y0i_over2); + + // xR = 1/sqrt(2) and xI = -1/sqrt(2) + // For denominator: bit_met_den_im_p = abs_psi_rmm + abs_psi_ipp + y0r/sqrt(2) - y0i/sqrt(2) + simde__m256i bit_met_den_im_p = simde_mm256_adds_epi16(abs_psi_rmm, abs_psi_ipp); + bit_met_den_im_p = simde_mm256_adds_epi16(bit_met_den_im_p, y0r_over2); + bit_met_den_im_p = simde_mm256_subs_epi16(bit_met_den_im_p, y0i_over2); + + // xR = -1/sqrt(2) and xI = -1/sqrt(2) + // For denominator: bit_met_den_im_m = abs_psi_rpp + abs_psi_imp - y0r/sqrt(2)- y0i/sqrt(2) + simde__m256i bit_met_den_im_m = simde_mm256_adds_epi16(abs_psi_rpp, abs_psi_imp); + bit_met_den_im_m = simde_mm256_subs_epi16(bit_met_den_im_m, y0r_over2); + bit_met_den_im_m = simde_mm256_subs_epi16(bit_met_den_im_m, y0i_over2); + + /// Compute the LLRs + + // LLR = lambda(c==1) - lambda(c==0) + + simde__m256i logmax_num_re0 = simde_mm256_max_epi16(bit_met_num_re_p, bit_met_num_re_m); // LLR of the first bit: Bit = 1 + simde__m256i logmax_den_re0 = simde_mm256_max_epi16(bit_met_den_re_p, bit_met_den_re_m); // LLR of the first bit: Bit = 0 + simde__m256i logmax_num_im0 = simde_mm256_max_epi16(bit_met_num_im_p, bit_met_num_im_m); // LLR of the second bit: Bit = 1 + simde__m256i logmax_den_im0 = simde_mm256_max_epi16(bit_met_den_im_p, bit_met_den_im_m); // LLR of the second bit: Bit = 0 + + y0r = simde_mm256_subs_epi16(logmax_num_re0, logmax_den_re0); // LLR of first bit [L1(1), L1(2), L1(3), L1(4), L1(5), L1(6), L1(7), L1(8)] + y0i = simde_mm256_subs_epi16(logmax_num_im0, logmax_den_im0); // LLR of second bit [L2(1), L2(2), L2(3), L2(4), L2(5), L2(6), L2(7), L2(8)] + + // [L1(1), L2(1), L1(2), L2(2) ...] + simde__m128i * stream0_128i_out = (simde__m128i *)&stream0_256i_out[i]; + simde__m128i * y0r_128 = (simde__m128i *) &y0r; + simde__m128i * y0i_128 = (simde__m128i *) &y0i; + simde_mm_storeu_si128(&stream0_128i_out[0], simde_mm_unpacklo_epi16(y0r_128[0], y0i_128[0])); + simde_mm_storeu_si128(&stream0_128i_out[1], simde_mm_unpackhi_epi16(y0r_128[0], y0i_128[0])); + + // false if only 4 REs remain + if (i < ((length >> 2) - 1)) + { + simde__m128i * stream0_128i_out = (simde__m128i *)&stream0_256i_out[i + 1]; + simde_mm_storeu_si128(&stream0_128i_out[0], simde_mm_unpacklo_epi16(y0r_128[1], y0i_128[1])); + simde_mm_storeu_si128(&stream0_128i_out[1], simde_mm_unpackhi_epi16(y0r_128[1], y0i_128[1])); + } + } +#endif simde_mm_empty(); simde_m_empty(); } + static const int16_t ones[8] __attribute__((aligned(16))) = {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff}; +static const int16_t ones256[16] __attribute__((aligned(32))) = {0xffff, + 0xffff, + 0xffff, + 0xffff, + 0xffff, + 0xffff, + 0xffff, + 0xffff, + 0xffff, + 0xffff, + 0xffff, + 0xffff, + 0xffff, + 0xffff, + 0xffff, + 0xffff}; + +// calculate interference magnitude +// tmp_result = ones in shorts corr. to interval 2<=x<=4, tmp_result2 interval < 2, tmp_result3 interval 46 +#define interference_abs_64qam_epi16(psi, int_ch_mag, int_two_ch_mag, int_three_ch_mag, a, c1, c3, c5, c7) \ + tmp_result = simde_mm_cmpgt_epi16(int_two_ch_mag, psi); \ + tmp_result3 = simde_mm_xor_si128(tmp_result, (*(simde__m128i *)&ones[0])); \ + tmp_result2 = simde_mm_cmpgt_epi16(int_ch_mag, psi); \ + tmp_result = simde_mm_xor_si128(tmp_result, tmp_result2); \ + tmp_result4 = simde_mm_cmpgt_epi16(psi, int_three_ch_mag); \ + tmp_result3 = simde_mm_xor_si128(tmp_result3, tmp_result4); \ + tmp_result = simde_mm_and_si128(tmp_result, c3); \ + tmp_result2 = simde_mm_and_si128(tmp_result2, c1); \ + tmp_result3 = simde_mm_and_si128(tmp_result3, c5); \ + tmp_result4 = simde_mm_and_si128(tmp_result4, c7); \ + tmp_result = simde_mm_or_si128(tmp_result, tmp_result2); \ + tmp_result3 = simde_mm_or_si128(tmp_result3, tmp_result4); \ + const simde__m128i a = simde_mm_or_si128(tmp_result, tmp_result3); + + +// calculate interference magnitude +// tmp_result = ones in shorts corr. to interval 2<=x<=4, tmp_result2 interval < 2, tmp_result3 interval 46 +#define interference_abs_64qam_epi16_256(psi, int_ch_mag, int_two_ch_mag, int_three_ch_mag, a, c1, c3, c5, c7) \ + tmp_result = simde_mm256_cmpgt_epi16(int_two_ch_mag, psi); \ + tmp_result3 = simde_mm256_xor_si256(tmp_result, (*(simde__m256i *)&ones256[0])); \ + tmp_result2 = simde_mm256_cmpgt_epi16(int_ch_mag, psi); \ + tmp_result = simde_mm256_xor_si256(tmp_result, tmp_result2); \ + tmp_result4 = simde_mm256_cmpgt_epi16(psi, int_three_ch_mag); \ + tmp_result3 = simde_mm256_xor_si256(tmp_result3, tmp_result4); \ + tmp_result = simde_mm256_and_si256(tmp_result, c3); \ + tmp_result2 = simde_mm256_and_si256(tmp_result2, c1); \ + tmp_result3 = simde_mm256_and_si256(tmp_result3, c5); \ + tmp_result4 = simde_mm256_and_si256(tmp_result4, c7); \ + tmp_result = simde_mm256_or_si256(tmp_result, tmp_result2); \ + tmp_result3 = simde_mm256_or_si256(tmp_result3, tmp_result4); \ + const simde__m256i a = simde_mm256_or_si256(tmp_result, tmp_result3); + // Calculates psi_a = psi_r * a_r + psi_i * a_i #define prodsum_psi_a_epi16(psi_r, a_r, psi_i, a_i, psi_a) \ tmp_result = simde_mm_mulhi_epi16(psi_r, a_r); \ tmp_result = simde_mm_slli_epi16(tmp_result, 1); \ tmp_result2 = simde_mm_mulhi_epi16(psi_i, a_i); \ tmp_result2 = simde_mm_slli_epi16(tmp_result2, 1); \ - psi_a = simde_mm_adds_epi16(tmp_result, tmp_result2); + simde__m128i psi_a = simde_mm_adds_epi16(tmp_result, tmp_result2); + +// calculates psi_a = psi_r*a_r + psi_i*a_i +#define prodsum_psi_a_epi16_256(psi_r, a_r, psi_i, a_i, psi_a) \ + tmp_result = simde_mm256_mulhi_epi16(psi_r, a_r); \ + tmp_result = simde_mm256_slli_epi16(tmp_result, 1); \ + tmp_result2 = simde_mm256_mulhi_epi16(psi_i, a_i); \ + tmp_result2 = simde_mm256_slli_epi16(tmp_result2, 1); \ + simde__m256i psi_a = simde_mm256_adds_epi16(tmp_result, tmp_result2); // Calculate interference magnitude #define interference_abs_epi16(psi, int_ch_mag, int_mag, c1, c2) \ @@ -429,6 +654,14 @@ static const int16_t ones[8] __attribute__((aligned(16))) = {0xffff, 0xffff, 0xf tmp_result2 = simde_mm_and_si128(tmp_result2, c2); \ int_mag = simde_mm_or_si128(tmp_result, tmp_result2); +// Calculate interference magnitude +#define interference_abs_epi16_256(psi, int_ch_mag, int_mag, c1, c2) \ + tmp_result = simde_mm256_cmpgt_epi16(int_ch_mag, psi); \ + tmp_result2 = simde_mm256_xor_si256(tmp_result, (*(simde__m256i *)&ones256[0])); \ + tmp_result = simde_mm256_and_si256(tmp_result, c1); \ + tmp_result2 = simde_mm256_and_si256(tmp_result2, c2); \ + int_mag = simde_mm256_or_si256(tmp_result, tmp_result2); + // Calculates a_sq = int_ch_mag * (a_r^2 + a_i^2) * scale_factor #define square_a_epi16(a_r, a_i, int_ch_mag, scale_factor, a_sq) \ tmp_result = simde_mm_mulhi_epi16(a_r, a_r); \ @@ -445,6 +678,55 @@ static const int16_t ones[8] __attribute__((aligned(16))) = {0xffff, 0xffff, 0xf tmp_result2 = simde_mm_slli_epi16(tmp_result2, 1); \ a_sq = simde_mm_adds_epi16(tmp_result, tmp_result2); +// Calculates a_sq = int_ch_mag * (a_r^2 + a_i^2) * scale_factor +#define square_a_epi16_256(a_r, a_i, int_ch_mag, scale_factor, a_sq) \ + tmp_result = simde_mm256_mulhi_epi16(a_r, a_r); \ + tmp_result = simde_mm256_slli_epi16(tmp_result, 1); \ + tmp_result = simde_mm256_mulhi_epi16(tmp_result, scale_factor); \ + tmp_result = simde_mm256_slli_epi16(tmp_result, 1); \ + tmp_result = simde_mm256_mulhi_epi16(tmp_result, int_ch_mag); \ + tmp_result = simde_mm256_slli_epi16(tmp_result, 1); \ + tmp_result2 = simde_mm256_mulhi_epi16(a_i, a_i); \ + tmp_result2 = simde_mm256_slli_epi16(tmp_result2, 1); \ + tmp_result2 = simde_mm256_mulhi_epi16(tmp_result2, scale_factor); \ + tmp_result2 = simde_mm256_slli_epi16(tmp_result2, 1); \ + tmp_result2 = simde_mm256_mulhi_epi16(tmp_result2, int_ch_mag); \ + tmp_result2 = simde_mm256_slli_epi16(tmp_result2, 1); \ + a_sq = simde_mm256_adds_epi16(tmp_result, tmp_result2); + +// calculates a_sq = int_ch_mag*(a_r^2 + a_i^2)*scale_factor for 64-QAM +#define square_a_64qam_epi16(a_r, a_i, int_ch_mag, scale_factor, a_sq) \ + tmp_result = simde_mm_mulhi_epi16(a_r, a_r); \ + tmp_result = simde_mm_slli_epi16(tmp_result, 1); \ + tmp_result = simde_mm_mulhi_epi16(tmp_result, scale_factor); \ + tmp_result = simde_mm_slli_epi16(tmp_result, 3); \ + tmp_result = simde_mm_mulhi_epi16(tmp_result, int_ch_mag); \ + tmp_result = simde_mm_slli_epi16(tmp_result, 1); \ + tmp_result2 = simde_mm_mulhi_epi16(a_i, a_i); \ + tmp_result2 = simde_mm_slli_epi16(tmp_result2, 1); \ + tmp_result2 = simde_mm_mulhi_epi16(tmp_result2, scale_factor); \ + tmp_result2 = simde_mm_slli_epi16(tmp_result2, 3); \ + tmp_result2 = simde_mm_mulhi_epi16(tmp_result2, int_ch_mag); \ + tmp_result2 = simde_mm_slli_epi16(tmp_result2, 1); \ + const simde__m128i a_sq = simde_mm_adds_epi16(tmp_result, tmp_result2); + + +// calculates a_sq = int_ch_mag*(a_r^2 + a_i^2)*scale_factor for 64-QAM +#define square_a_64qam_epi16_256(a_r, a_i, int_ch_mag, scale_factor, a_sq) \ + tmp_result = simde_mm256_mulhi_epi16(a_r, a_r); \ + tmp_result = simde_mm256_slli_epi16(tmp_result, 1); \ + tmp_result = simde_mm256_mulhi_epi16(tmp_result, scale_factor); \ + tmp_result = simde_mm256_slli_epi16(tmp_result, 3); \ + tmp_result = simde_mm256_mulhi_epi16(tmp_result, int_ch_mag); \ + tmp_result = simde_mm256_slli_epi16(tmp_result, 1); \ + tmp_result2 = simde_mm256_mulhi_epi16(a_i, a_i); \ + tmp_result2 = simde_mm256_slli_epi16(tmp_result2, 1); \ + tmp_result2 = simde_mm256_mulhi_epi16(tmp_result2, scale_factor); \ + tmp_result2 = simde_mm256_slli_epi16(tmp_result2, 3); \ + tmp_result2 = simde_mm256_mulhi_epi16(tmp_result2, int_ch_mag); \ + tmp_result2 = simde_mm256_slli_epi16(tmp_result2, 1); \ + const simde__m256i a_sq = simde_mm256_adds_epi16(tmp_result, tmp_result2); + simde__m128i max_epi16(simde__m128i m0, simde__m128i m1, simde__m128i m2, simde__m128i m3, simde__m128i m4, simde__m128i m5, simde__m128i m6, simde__m128i m7) { simde__m128i a0 = simde_mm_max_epi16(m0, m1); @@ -456,6 +738,17 @@ simde__m128i max_epi16(simde__m128i m0, simde__m128i m1, simde__m128i m2, simde_ return simde_mm_max_epi16(b0, b1); } +simde__m256i max_epi16_256(simde__m256i m0, simde__m256i m1, simde__m256i m2, simde__m256i m3, simde__m256i m4, simde__m256i m5, simde__m256i m6, simde__m256i m7) +{ + simde__m256i a0 = simde_mm256_max_epi16(m0, m1); + simde__m256i a1 = simde_mm256_max_epi16(m2, m3); + simde__m256i a2 = simde_mm256_max_epi16(m4, m5); + simde__m256i a3 = simde_mm256_max_epi16(m6, m7); + simde__m256i b0 = simde_mm256_max_epi16(a0, a1); + simde__m256i b1 = simde_mm256_max_epi16(a2, a3); + return simde_mm256_max_epi16(b0, b1); +} + /* * This function computes the LLRs of stream 0 (s_0) in presence of the interfering stream 1 (s_1) assuming that both symbols are * 16QAM. It can be used for both MU-MIMO interference-aware receiver or for SU-MIMO receivers. @@ -479,6 +772,7 @@ void nr_ulsch_qam16_qam16(c16_t *stream0_in, c16_t *rho01, uint32_t length) { +#ifdef USE_128BIT simde__m128i *rho01_128i = (simde__m128i *)rho01; simde__m128i *stream0_128i_in = (simde__m128i *)stream0_in; simde__m128i *stream1_128i_in = (simde__m128i *)stream1_in; @@ -1013,72 +1307,561 @@ void nr_ulsch_qam16_qam16(c16_t *stream0_in, stream0_128i_out[2 * i + 2] = simde_mm_unpacklo_epi32(xmm1, xmm3); // 8 LLRs, 2 REs stream0_128i_out[2 * i + 3] = simde_mm_unpackhi_epi32(xmm1, xmm3); // 8 LLRs, 2 REs } +#else + simde__m256i *rho01_256i = (simde__m256i *)rho01; + simde__m256i *stream0_256i_in = (simde__m256i *)stream0_in; + simde__m256i *stream1_256i_in = (simde__m256i *)stream1_in; + simde__m256i *stream0_256i_out = (simde__m256i *)stream0_out; + simde__m256i *ch_mag_256i = (simde__m256i *)ch_mag; + simde__m256i *ch_mag_256i_i = (simde__m256i *)ch_mag_i; + simde__m256i ONE_OVER_SQRT_10 = simde_mm256_set1_epi16(20724); // round(1/sqrt(10)*2^16) + simde__m256i ONE_OVER_SQRT_10_Q15 = simde_mm256_set1_epi16(10362); // round(1/sqrt(10)*2^15) + simde__m256i THREE_OVER_SQRT_10 = simde_mm256_set1_epi16(31086); // round(3/sqrt(10)*2^15) + simde__m256i SQRT_10_OVER_FOUR = simde_mm256_set1_epi16(25905); // round(sqrt(10)/4*2^15) + simde__m256i ONE_OVER_TWO_SQRT_10 = simde_mm256_set1_epi16(10362); // round(1/2/sqrt(10)*2^16) + simde__m256i NINE_OVER_TWO_SQRT_10 = simde_mm256_set1_epi16(23315); // round(9/2/sqrt(10)*2^14) + simde__m256i ch_mag_des, ch_mag_int; + simde__m256i y0r_over_sqrt10; + simde__m256i y0i_over_sqrt10; + simde__m256i y0r_three_over_sqrt10; + simde__m256i y0i_three_over_sqrt10; + simde__m256i ch_mag_over_10; + simde__m256i ch_mag_over_2; + simde__m256i ch_mag_9_over_10; + + simde__m256i xmm0 __attribute__((aligned(16))); + simde__m256i xmm1 __attribute__((aligned(16))); + simde__m256i xmm2 __attribute__((aligned(16))); + simde__m256i xmm3 __attribute__((aligned(16))); + simde__m256i xmm4 __attribute__((aligned(16))); + simde__m256i xmm5 __attribute__((aligned(16))); + simde__m256i xmm6 __attribute__((aligned(16))); + simde__m256i xmm7 __attribute__((aligned(16))); + + simde__m256i rho_rpi __attribute__((aligned(16))); + simde__m256i rho_rmi __attribute__((aligned(16))); + simde__m256i rho_rpi_1_1 __attribute__((aligned(16))); + simde__m256i rho_rpi_1_3 __attribute__((aligned(16))); + simde__m256i rho_rpi_3_1 __attribute__((aligned(16))); + simde__m256i rho_rpi_3_3 __attribute__((aligned(16))); + simde__m256i rho_rmi_1_1 __attribute__((aligned(16))); + simde__m256i rho_rmi_1_3 __attribute__((aligned(16))); + simde__m256i rho_rmi_3_1 __attribute__((aligned(16))); + simde__m256i rho_rmi_3_3 __attribute__((aligned(16))); + + simde__m256i psi_r_m3_m3 __attribute__((aligned(16))); + simde__m256i psi_r_m3_m1 __attribute__((aligned(16))); + simde__m256i psi_r_m3_p1 __attribute__((aligned(16))); + simde__m256i psi_r_m3_p3 __attribute__((aligned(16))); + simde__m256i psi_r_m1_m3 __attribute__((aligned(16))); + simde__m256i psi_r_m1_m1 __attribute__((aligned(16))); + simde__m256i psi_r_m1_p1 __attribute__((aligned(16))); + simde__m256i psi_r_m1_p3 __attribute__((aligned(16))); + simde__m256i psi_r_p1_m3 __attribute__((aligned(16))); + simde__m256i psi_r_p1_m1 __attribute__((aligned(16))); + simde__m256i psi_r_p1_p1 __attribute__((aligned(16))); + simde__m256i psi_r_p1_p3 __attribute__((aligned(16))); + simde__m256i psi_r_p3_m3 __attribute__((aligned(16))); + simde__m256i psi_r_p3_m1 __attribute__((aligned(16))); + simde__m256i psi_r_p3_p1 __attribute__((aligned(16))); + simde__m256i psi_r_p3_p3 __attribute__((aligned(16))); + + simde__m256i psi_i_m3_m3 __attribute__((aligned(16))); + simde__m256i psi_i_m3_m1 __attribute__((aligned(16))); + simde__m256i psi_i_m3_p1 __attribute__((aligned(16))); + simde__m256i psi_i_m3_p3 __attribute__((aligned(16))); + simde__m256i psi_i_m1_m3 __attribute__((aligned(16))); + simde__m256i psi_i_m1_m1 __attribute__((aligned(16))); + simde__m256i psi_i_m1_p1 __attribute__((aligned(16))); + simde__m256i psi_i_m1_p3 __attribute__((aligned(16))); + simde__m256i psi_i_p1_m3 __attribute__((aligned(16))); + simde__m256i psi_i_p1_m1 __attribute__((aligned(16))); + simde__m256i psi_i_p1_p1 __attribute__((aligned(16))); + simde__m256i psi_i_p1_p3 __attribute__((aligned(16))); + simde__m256i psi_i_p3_m3 __attribute__((aligned(16))); + simde__m256i psi_i_p3_m1 __attribute__((aligned(16))); + simde__m256i psi_i_p3_p1 __attribute__((aligned(16))); + simde__m256i psi_i_p3_p3 __attribute__((aligned(16))); + + simde__m256i a_r_m3_m3 __attribute__((aligned(16))); + simde__m256i a_r_m3_m1 __attribute__((aligned(16))); + simde__m256i a_r_m3_p1 __attribute__((aligned(16))); + simde__m256i a_r_m3_p3 __attribute__((aligned(16))); + simde__m256i a_r_m1_m3 __attribute__((aligned(16))); + simde__m256i a_r_m1_m1 __attribute__((aligned(16))); + simde__m256i a_r_m1_p1 __attribute__((aligned(16))); + simde__m256i a_r_m1_p3 __attribute__((aligned(16))); + simde__m256i a_r_p1_m3 __attribute__((aligned(16))); + simde__m256i a_r_p1_m1 __attribute__((aligned(16))); + simde__m256i a_r_p1_p1 __attribute__((aligned(16))); + simde__m256i a_r_p1_p3 __attribute__((aligned(16))); + simde__m256i a_r_p3_m3 __attribute__((aligned(16))); + simde__m256i a_r_p3_m1 __attribute__((aligned(16))); + simde__m256i a_r_p3_p1 __attribute__((aligned(16))); + simde__m256i a_r_p3_p3 __attribute__((aligned(16))); + + simde__m256i a_i_m3_m3 __attribute__((aligned(16))); + simde__m256i a_i_m3_m1 __attribute__((aligned(16))); + simde__m256i a_i_m3_p1 __attribute__((aligned(16))); + simde__m256i a_i_m3_p3 __attribute__((aligned(16))); + simde__m256i a_i_m1_m3 __attribute__((aligned(16))); + simde__m256i a_i_m1_m1 __attribute__((aligned(16))); + simde__m256i a_i_m1_p1 __attribute__((aligned(16))); + simde__m256i a_i_m1_p3 __attribute__((aligned(16))); + simde__m256i a_i_p1_m3 __attribute__((aligned(16))); + simde__m256i a_i_p1_m1 __attribute__((aligned(16))); + simde__m256i a_i_p1_p1 __attribute__((aligned(16))); + simde__m256i a_i_p1_p3 __attribute__((aligned(16))); + simde__m256i a_i_p3_m3 __attribute__((aligned(16))); + simde__m256i a_i_p3_m1 __attribute__((aligned(16))); + simde__m256i a_i_p3_p1 __attribute__((aligned(16))); + simde__m256i a_i_p3_p3 __attribute__((aligned(16))); + + simde__m256i psi_a_m3_m3 __attribute__((aligned(16))); + simde__m256i psi_a_m3_m1 __attribute__((aligned(16))); + simde__m256i psi_a_m3_p1 __attribute__((aligned(16))); + simde__m256i psi_a_m3_p3 __attribute__((aligned(16))); + simde__m256i psi_a_m1_m3 __attribute__((aligned(16))); + simde__m256i psi_a_m1_m1 __attribute__((aligned(16))); + simde__m256i psi_a_m1_p1 __attribute__((aligned(16))); + simde__m256i psi_a_m1_p3 __attribute__((aligned(16))); + simde__m256i psi_a_p1_m3 __attribute__((aligned(16))); + simde__m256i psi_a_p1_m1 __attribute__((aligned(16))); + simde__m256i psi_a_p1_p1 __attribute__((aligned(16))); + simde__m256i psi_a_p1_p3 __attribute__((aligned(16))); + simde__m256i psi_a_p3_m3 __attribute__((aligned(16))); + simde__m256i psi_a_p3_m1 __attribute__((aligned(16))); + simde__m256i psi_a_p3_p1 __attribute__((aligned(16))); + simde__m256i psi_a_p3_p3 __attribute__((aligned(16))); + + simde__m256i a_sq_m3_m3 __attribute__((aligned(16))); + simde__m256i a_sq_m3_m1 __attribute__((aligned(16))); + simde__m256i a_sq_m3_p1 __attribute__((aligned(16))); + simde__m256i a_sq_m3_p3 __attribute__((aligned(16))); + simde__m256i a_sq_m1_m3 __attribute__((aligned(16))); + simde__m256i a_sq_m1_m1 __attribute__((aligned(16))); + simde__m256i a_sq_m1_p1 __attribute__((aligned(16))); + simde__m256i a_sq_m1_p3 __attribute__((aligned(16))); + simde__m256i a_sq_p1_m3 __attribute__((aligned(16))); + simde__m256i a_sq_p1_m1 __attribute__((aligned(16))); + simde__m256i a_sq_p1_p1 __attribute__((aligned(16))); + simde__m256i a_sq_p1_p3 __attribute__((aligned(16))); + simde__m256i a_sq_p3_m3 __attribute__((aligned(16))); + simde__m256i a_sq_p3_m1 __attribute__((aligned(16))); + simde__m256i a_sq_p3_p1 __attribute__((aligned(16))); + simde__m256i a_sq_p3_p3 __attribute__((aligned(16))); + + simde__m256i y0_p_1_1 __attribute__((aligned(16))); + simde__m256i y0_p_1_3 __attribute__((aligned(16))); + simde__m256i y0_p_3_1 __attribute__((aligned(16))); + simde__m256i y0_p_3_3 __attribute__((aligned(16))); + simde__m256i y0_m_1_1 __attribute__((aligned(16))); + simde__m256i y0_m_1_3 __attribute__((aligned(16))); + simde__m256i y0_m_3_1 __attribute__((aligned(16))); + simde__m256i y0_m_3_3 __attribute__((aligned(16))); + + simde__m256i y0r __attribute__((aligned(16))); + simde__m256i y0i __attribute__((aligned(16))); + simde__m256i y1r __attribute__((aligned(16))); + simde__m256i y1i __attribute__((aligned(16))); + + simde__m256i tmp_result __attribute__((aligned(16))); + simde__m256i tmp_result2 __attribute__((aligned(16))); + + // In one iteration, we deal with 8 REs + for (int i = 0; i < length >> 3; i += 2) { + + // Get rho + simde_mm256_separate_real_imag_parts(&xmm2, &xmm3, rho01_256i[i], rho01_256i[i + 1]); + rho_rpi = simde_mm256_adds_epi16(xmm2, xmm3); // rho = Re(rho) + Im(rho) + rho_rmi = simde_mm256_subs_epi16(xmm2, xmm3); // rho* = Re(rho) - Im(rho) + + // Compute the different rhos + rho_rpi_1_1 = simde_mm256_mulhi_epi16(rho_rpi, ONE_OVER_SQRT_10); + rho_rmi_1_1 = simde_mm256_mulhi_epi16(rho_rmi, ONE_OVER_SQRT_10); + rho_rpi_3_3 = simde_mm256_mulhi_epi16(rho_rpi, THREE_OVER_SQRT_10); + rho_rmi_3_3 = simde_mm256_mulhi_epi16(rho_rmi, THREE_OVER_SQRT_10); + rho_rpi_3_3 = simde_mm256_slli_epi16(rho_rpi_3_3, 1); + rho_rmi_3_3 = simde_mm256_slli_epi16(rho_rmi_3_3, 1); + + xmm4 = simde_mm256_mulhi_epi16(xmm2, ONE_OVER_SQRT_10); // Re(rho) + xmm5 = simde_mm256_mulhi_epi16(xmm3, THREE_OVER_SQRT_10); // Im(rho) + xmm5 = simde_mm256_slli_epi16(xmm5, 1); + + rho_rpi_1_3 = simde_mm256_adds_epi16(xmm4, xmm5); + rho_rmi_1_3 = simde_mm256_subs_epi16(xmm4, xmm5); + + xmm6 = simde_mm256_mulhi_epi16(xmm2, THREE_OVER_SQRT_10); // Re(rho) + xmm7 = simde_mm256_mulhi_epi16(xmm3, ONE_OVER_SQRT_10); // Im(rho) + xmm6 = simde_mm256_slli_epi16(xmm6, 1); + + rho_rpi_3_1 = simde_mm256_adds_epi16(xmm6, xmm7); + rho_rmi_3_1 = simde_mm256_subs_epi16(xmm6, xmm7); + + // Rearrange interfering MF output + simde_mm256_separate_real_imag_parts(&y1r, &y1i, stream1_256i_in[i], stream1_256i_in[i + 1]); + + xmm0 = simde_mm256_setzero_si256(); // ZERO + xmm2 = simde_mm256_subs_epi16(rho_rpi_1_1, y1r); // = [Re(rho)+ Im(rho)]/sqrt(10) - y1r + psi_r_p1_p1 = simde_mm256_abs_epi16(xmm2); // = |[Re(rho)+ Im(rho)]/sqrt(10) - y1r| + + xmm2 = simde_mm256_subs_epi16(rho_rmi_1_1, y1r); + psi_r_p1_m1 = simde_mm256_abs_epi16(xmm2); + xmm2 = simde_mm256_subs_epi16(rho_rmi_1_1, y1i); + psi_i_p1_p1 = simde_mm256_abs_epi16(xmm2); + xmm2 = simde_mm256_subs_epi16(rho_rpi_1_3, y1r); + psi_r_p1_p3 = simde_mm256_abs_epi16(xmm2); + xmm2 = simde_mm256_subs_epi16(rho_rmi_1_3, y1r); + psi_r_p1_m3 = simde_mm256_abs_epi16(xmm2); + xmm2 = simde_mm256_subs_epi16(rho_rmi_3_1, y1i); + psi_i_p1_p3 = simde_mm256_abs_epi16(xmm2); + xmm2 = simde_mm256_subs_epi16(rho_rpi_3_1, y1r); + psi_r_p3_p1 = simde_mm256_abs_epi16(xmm2); + xmm2 = simde_mm256_subs_epi16(rho_rmi_3_1, y1r); + psi_r_p3_m1 = simde_mm256_abs_epi16(xmm2); + xmm2 = simde_mm256_subs_epi16(rho_rmi_1_3, y1i); + psi_i_p3_p1 = simde_mm256_abs_epi16(xmm2); + xmm2 = simde_mm256_subs_epi16(rho_rpi_3_3, y1r); + psi_r_p3_p3 = simde_mm256_abs_epi16(xmm2); + xmm2 = simde_mm256_subs_epi16(rho_rmi_3_3, y1r); + psi_r_p3_m3 = simde_mm256_abs_epi16(xmm2); + xmm2 = simde_mm256_subs_epi16(rho_rmi_3_3, y1i); + psi_i_p3_p3 = simde_mm256_abs_epi16(xmm2); + xmm2 = simde_mm256_subs_epi16(rho_rpi_1_1, y1i); + psi_i_m1_p1 = simde_mm256_abs_epi16(xmm2); + xmm2 = simde_mm256_subs_epi16(rho_rpi_3_1, y1i); + psi_i_m1_p3 = simde_mm256_abs_epi16(xmm2); + xmm2 = simde_mm256_subs_epi16(rho_rpi_1_3, y1i); + psi_i_m3_p1 = simde_mm256_abs_epi16(xmm2); + xmm2 = simde_mm256_subs_epi16(rho_rpi_3_3, y1i); + psi_i_m3_p3 = simde_mm256_abs_epi16(xmm2); + xmm2 = simde_mm256_adds_epi16(rho_rpi_1_1, y1i); + psi_i_p1_m1 = simde_mm256_abs_epi16(xmm2); + xmm2 = simde_mm256_adds_epi16(rho_rpi_3_1, y1i); + psi_i_p1_m3 = simde_mm256_abs_epi16(xmm2); + xmm2 = simde_mm256_adds_epi16(rho_rpi_1_3, y1i); + psi_i_p3_m1 = simde_mm256_abs_epi16(xmm2); + xmm2 = simde_mm256_adds_epi16(rho_rpi_3_3, y1i); + psi_i_p3_m3 = simde_mm256_abs_epi16(xmm2); + xmm2 = simde_mm256_adds_epi16(rho_rpi_1_1, y1r); + psi_r_m1_m1 = simde_mm256_abs_epi16(xmm2); + xmm2 = simde_mm256_adds_epi16(rho_rpi_1_3, y1r); + psi_r_m1_m3 = simde_mm256_abs_epi16(xmm2); + xmm2 = simde_mm256_adds_epi16(rho_rpi_3_1, y1r); + psi_r_m3_m1 = simde_mm256_abs_epi16(xmm2); + xmm2 = simde_mm256_adds_epi16(rho_rpi_3_3, y1r); + psi_r_m3_m3 = simde_mm256_abs_epi16(xmm2); + xmm2 = simde_mm256_adds_epi16(y1r, rho_rmi_1_1); + psi_r_m1_p1 = simde_mm256_abs_epi16(xmm2); + xmm2 = simde_mm256_adds_epi16(y1r, rho_rmi_1_3); + psi_r_m1_p3 = simde_mm256_abs_epi16(xmm2); + xmm2 = simde_mm256_adds_epi16(y1i, rho_rmi_1_1); + psi_i_m1_m1 = simde_mm256_abs_epi16(xmm2); + xmm2 = simde_mm256_adds_epi16(y1i, rho_rmi_3_1); + psi_i_m1_m3 = simde_mm256_abs_epi16(xmm2); + xmm2 = simde_mm256_adds_epi16(y1r, rho_rmi_3_1); + psi_r_m3_p1 = simde_mm256_abs_epi16(xmm2); + xmm2 = simde_mm256_adds_epi16(y1r, rho_rmi_3_3); + psi_r_m3_p3 = simde_mm256_abs_epi16(xmm2); + xmm2 = simde_mm256_adds_epi16(y1i, rho_rmi_1_3); + psi_i_m3_m1 = simde_mm256_abs_epi16(xmm2); + xmm2 = simde_mm256_adds_epi16(y1i, rho_rmi_3_3); + psi_i_m3_m3 = simde_mm256_abs_epi16(xmm2); + + // Rearrange desired MF output + simde_mm256_separate_real_imag_parts(&y0r, &y0i, stream0_256i_in[i], stream0_256i_in[i + 1]); + + // Rearrange desired channel magnitudes + // [|h|^2(1),|h|^2(2),|h|^2(3),|h|^2(4)]*(2/sqrt(10)) + simde_mm256_separate_real_imag_parts(&ch_mag_des, &xmm2, ch_mag_256i[i], ch_mag_256i[i + 1]); + + // Rearrange interfering channel magnitudes + simde_mm256_separate_real_imag_parts(&ch_mag_int, &xmm2, ch_mag_256i_i[i], ch_mag_256i_i[i + 1]); + + // Scale MF output of desired signal + y0r_over_sqrt10 = simde_mm256_mulhi_epi16(y0r, ONE_OVER_SQRT_10); + y0i_over_sqrt10 = simde_mm256_mulhi_epi16(y0i, ONE_OVER_SQRT_10); + y0r_three_over_sqrt10 = simde_mm256_mulhi_epi16(y0r, THREE_OVER_SQRT_10); + y0i_three_over_sqrt10 = simde_mm256_mulhi_epi16(y0i, THREE_OVER_SQRT_10); + y0r_three_over_sqrt10 = simde_mm256_slli_epi16(y0r_three_over_sqrt10, 1); + y0i_three_over_sqrt10 = simde_mm256_slli_epi16(y0i_three_over_sqrt10, 1); + + // Compute necessary combination of required terms + y0_p_1_1 = simde_mm256_adds_epi16(y0r_over_sqrt10, y0i_over_sqrt10); + y0_m_1_1 = simde_mm256_subs_epi16(y0r_over_sqrt10, y0i_over_sqrt10); + + y0_p_1_3 = simde_mm256_adds_epi16(y0r_over_sqrt10, y0i_three_over_sqrt10); + y0_m_1_3 = simde_mm256_subs_epi16(y0r_over_sqrt10, y0i_three_over_sqrt10); + + y0_p_3_1 = simde_mm256_adds_epi16(y0r_three_over_sqrt10, y0i_over_sqrt10); + y0_m_3_1 = simde_mm256_subs_epi16(y0r_three_over_sqrt10, y0i_over_sqrt10); + + y0_p_3_3 = simde_mm256_adds_epi16(y0r_three_over_sqrt10, y0i_three_over_sqrt10); + y0_m_3_3 = simde_mm256_subs_epi16(y0r_three_over_sqrt10, y0i_three_over_sqrt10); + + // Compute optimal interfering symbol magnitude + interference_abs_epi16_256(psi_r_p1_p1, ch_mag_int, a_r_p1_p1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + interference_abs_epi16_256(psi_i_p1_p1, ch_mag_int, a_i_p1_p1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + interference_abs_epi16_256(psi_r_p1_p3, ch_mag_int, a_r_p1_p3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + interference_abs_epi16_256(psi_i_p1_p3, ch_mag_int, a_i_p1_p3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + interference_abs_epi16_256(psi_r_p1_m1, ch_mag_int, a_r_p1_m1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + interference_abs_epi16_256(psi_i_p1_m1, ch_mag_int, a_i_p1_m1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + interference_abs_epi16_256(psi_r_p1_m3, ch_mag_int, a_r_p1_m3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + interference_abs_epi16_256(psi_i_p1_m3, ch_mag_int, a_i_p1_m3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + interference_abs_epi16_256(psi_r_p3_p1, ch_mag_int, a_r_p3_p1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + interference_abs_epi16_256(psi_i_p3_p1, ch_mag_int, a_i_p3_p1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + interference_abs_epi16_256(psi_r_p3_p3, ch_mag_int, a_r_p3_p3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + interference_abs_epi16_256(psi_i_p3_p3, ch_mag_int, a_i_p3_p3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + interference_abs_epi16_256(psi_r_p3_m1, ch_mag_int, a_r_p3_m1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + interference_abs_epi16_256(psi_i_p3_m1, ch_mag_int, a_i_p3_m1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + interference_abs_epi16_256(psi_r_p3_m3, ch_mag_int, a_r_p3_m3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + interference_abs_epi16_256(psi_i_p3_m3, ch_mag_int, a_i_p3_m3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + interference_abs_epi16_256(psi_r_m1_p1, ch_mag_int, a_r_m1_p1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + interference_abs_epi16_256(psi_i_m1_p1, ch_mag_int, a_i_m1_p1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + interference_abs_epi16_256(psi_r_m1_p3, ch_mag_int, a_r_m1_p3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + interference_abs_epi16_256(psi_i_m1_p3, ch_mag_int, a_i_m1_p3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + interference_abs_epi16_256(psi_r_m1_m1, ch_mag_int, a_r_m1_m1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + interference_abs_epi16_256(psi_i_m1_m1, ch_mag_int, a_i_m1_m1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + interference_abs_epi16_256(psi_r_m1_m3, ch_mag_int, a_r_m1_m3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + interference_abs_epi16_256(psi_i_m1_m3, ch_mag_int, a_i_m1_m3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + interference_abs_epi16_256(psi_r_m3_p1, ch_mag_int, a_r_m3_p1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + interference_abs_epi16_256(psi_i_m3_p1, ch_mag_int, a_i_m3_p1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + interference_abs_epi16_256(psi_r_m3_p3, ch_mag_int, a_r_m3_p3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + interference_abs_epi16_256(psi_i_m3_p3, ch_mag_int, a_i_m3_p3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + interference_abs_epi16_256(psi_r_m3_m1, ch_mag_int, a_r_m3_m1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + interference_abs_epi16_256(psi_i_m3_m1, ch_mag_int, a_i_m3_m1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + interference_abs_epi16_256(psi_r_m3_m3, ch_mag_int, a_r_m3_m3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + interference_abs_epi16_256(psi_i_m3_m3, ch_mag_int, a_i_m3_m3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + + // Calculation of groups of two terms in the bit metric involving product of psi and interference magnitude + prodsum_psi_a_epi16_256(psi_r_p1_p1, a_r_p1_p1, psi_i_p1_p1, a_i_p1_p1, psi_a_p1_p1); + prodsum_psi_a_epi16_256(psi_r_p1_p3, a_r_p1_p3, psi_i_p1_p3, a_i_p1_p3, psi_a_p1_p3); + prodsum_psi_a_epi16_256(psi_r_p3_p1, a_r_p3_p1, psi_i_p3_p1, a_i_p3_p1, psi_a_p3_p1); + prodsum_psi_a_epi16_256(psi_r_p3_p3, a_r_p3_p3, psi_i_p3_p3, a_i_p3_p3, psi_a_p3_p3); + prodsum_psi_a_epi16_256(psi_r_p1_m1, a_r_p1_m1, psi_i_p1_m1, a_i_p1_m1, psi_a_p1_m1); + prodsum_psi_a_epi16_256(psi_r_p1_m3, a_r_p1_m3, psi_i_p1_m3, a_i_p1_m3, psi_a_p1_m3); + prodsum_psi_a_epi16_256(psi_r_p3_m1, a_r_p3_m1, psi_i_p3_m1, a_i_p3_m1, psi_a_p3_m1); + prodsum_psi_a_epi16_256(psi_r_p3_m3, a_r_p3_m3, psi_i_p3_m3, a_i_p3_m3, psi_a_p3_m3); + prodsum_psi_a_epi16_256(psi_r_m1_p1, a_r_m1_p1, psi_i_m1_p1, a_i_m1_p1, psi_a_m1_p1); + prodsum_psi_a_epi16_256(psi_r_m1_p3, a_r_m1_p3, psi_i_m1_p3, a_i_m1_p3, psi_a_m1_p3); + prodsum_psi_a_epi16_256(psi_r_m3_p1, a_r_m3_p1, psi_i_m3_p1, a_i_m3_p1, psi_a_m3_p1); + prodsum_psi_a_epi16_256(psi_r_m3_p3, a_r_m3_p3, psi_i_m3_p3, a_i_m3_p3, psi_a_m3_p3); + prodsum_psi_a_epi16_256(psi_r_m1_m1, a_r_m1_m1, psi_i_m1_m1, a_i_m1_m1, psi_a_m1_m1); + prodsum_psi_a_epi16_256(psi_r_m1_m3, a_r_m1_m3, psi_i_m1_m3, a_i_m1_m3, psi_a_m1_m3); + prodsum_psi_a_epi16_256(psi_r_m3_m1, a_r_m3_m1, psi_i_m3_m1, a_i_m3_m1, psi_a_m3_m1); + prodsum_psi_a_epi16_256(psi_r_m3_m3, a_r_m3_m3, psi_i_m3_m3, a_i_m3_m3, psi_a_m3_m3); + + // squared interference magnitude times int. ch. power + square_a_epi16_256(a_r_p1_p1, a_i_p1_p1, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_p1_p1); + square_a_epi16_256(a_r_p1_p3, a_i_p1_p3, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_p1_p3); + square_a_epi16_256(a_r_p3_p1, a_i_p3_p1, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_p3_p1); + square_a_epi16_256(a_r_p3_p3, a_i_p3_p3, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_p3_p3); + square_a_epi16_256(a_r_p1_m1, a_i_p1_m1, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_p1_m1); + square_a_epi16_256(a_r_p1_m3, a_i_p1_m3, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_p1_m3); + square_a_epi16_256(a_r_p3_m1, a_i_p3_m1, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_p3_m1); + square_a_epi16_256(a_r_p3_m3, a_i_p3_m3, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_p3_m3); + square_a_epi16_256(a_r_m1_p1, a_i_m1_p1, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_m1_p1); + square_a_epi16_256(a_r_m1_p3, a_i_m1_p3, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_m1_p3); + square_a_epi16_256(a_r_m3_p1, a_i_m3_p1, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_m3_p1); + square_a_epi16_256(a_r_m3_p3, a_i_m3_p3, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_m3_p3); + square_a_epi16_256(a_r_m1_m1, a_i_m1_m1, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_m1_m1); + square_a_epi16_256(a_r_m1_m3, a_i_m1_m3, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_m1_m3); + square_a_epi16_256(a_r_m3_m1, a_i_m3_m1, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_m3_m1); + square_a_epi16_256(a_r_m3_m3, a_i_m3_m3, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_m3_m3); + + // Computing different multiples of channel norms + ch_mag_over_10 = simde_mm256_mulhi_epi16(ch_mag_des, ONE_OVER_TWO_SQRT_10); + ch_mag_over_2 = simde_mm256_mulhi_epi16(ch_mag_des, SQRT_10_OVER_FOUR); + ch_mag_over_2 = simde_mm256_slli_epi16(ch_mag_over_2, 1); + ch_mag_9_over_10 = simde_mm256_mulhi_epi16(ch_mag_des, NINE_OVER_TWO_SQRT_10); + ch_mag_9_over_10 = simde_mm256_slli_epi16(ch_mag_9_over_10, 2); + + /// Compute bit metrics (lambda) + + simde__m256i bit_met_p1_p1 = simde_mm256_subs_epi16(psi_a_p1_p1, a_sq_p1_p1); + bit_met_p1_p1 = simde_mm256_adds_epi16(bit_met_p1_p1, y0_p_1_1); + bit_met_p1_p1 = simde_mm256_subs_epi16(bit_met_p1_p1, ch_mag_over_10); + + simde__m256i bit_met_p1_p3 = simde_mm256_subs_epi16(psi_a_p1_p3, a_sq_p1_p3); + bit_met_p1_p3 = simde_mm256_adds_epi16(bit_met_p1_p3, y0_p_1_3); + bit_met_p1_p3 = simde_mm256_subs_epi16(bit_met_p1_p3, ch_mag_over_2); + + simde__m256i bit_met_p1_m1 = simde_mm256_subs_epi16(psi_a_p1_m1, a_sq_p1_m1); + bit_met_p1_m1 = simde_mm256_adds_epi16(bit_met_p1_m1, y0_m_1_1); + bit_met_p1_m1 = simde_mm256_subs_epi16(bit_met_p1_m1, ch_mag_over_10); + + simde__m256i bit_met_p1_m3 = simde_mm256_subs_epi16(psi_a_p1_m3, a_sq_p1_m3); + bit_met_p1_m3 = simde_mm256_adds_epi16(bit_met_p1_m3, y0_m_1_3); + bit_met_p1_m3 = simde_mm256_subs_epi16(bit_met_p1_m3, ch_mag_over_2); + + simde__m256i bit_met_p3_p1 = simde_mm256_subs_epi16(psi_a_p3_p1, a_sq_p3_p1); + bit_met_p3_p1 = simde_mm256_adds_epi16(bit_met_p3_p1, y0_p_3_1); + bit_met_p3_p1 = simde_mm256_subs_epi16(bit_met_p3_p1, ch_mag_over_2); + + simde__m256i bit_met_p3_p3 = simde_mm256_subs_epi16(psi_a_p3_p3, a_sq_p3_p3); + bit_met_p3_p3 = simde_mm256_adds_epi16(bit_met_p3_p3, y0_p_3_3); + bit_met_p3_p3 = simde_mm256_subs_epi16(bit_met_p3_p3, ch_mag_9_over_10); + + simde__m256i bit_met_p3_m1 = simde_mm256_subs_epi16(psi_a_p3_m1, a_sq_p3_m1); + bit_met_p3_m1 = simde_mm256_adds_epi16(bit_met_p3_m1, y0_m_3_1); + bit_met_p3_m1 = simde_mm256_subs_epi16(bit_met_p3_m1, ch_mag_over_2); + + simde__m256i bit_met_p3_m3 = simde_mm256_subs_epi16(psi_a_p3_m3, a_sq_p3_m3); + bit_met_p3_m3 = simde_mm256_adds_epi16(bit_met_p3_m3, y0_m_3_3); + bit_met_p3_m3 = simde_mm256_subs_epi16(bit_met_p3_m3, ch_mag_9_over_10); + + simde__m256i bit_met_m1_p1 = simde_mm256_subs_epi16(psi_a_m1_p1, a_sq_m1_p1); + bit_met_m1_p1 = simde_mm256_subs_epi16(bit_met_m1_p1, y0_m_1_1); + bit_met_m1_p1 = simde_mm256_subs_epi16(bit_met_m1_p1, ch_mag_over_10); + + simde__m256i bit_met_m1_p3 = simde_mm256_subs_epi16(psi_a_m1_p3, a_sq_m1_p3); + bit_met_m1_p3 = simde_mm256_subs_epi16(bit_met_m1_p3, y0_m_1_3); + bit_met_m1_p3 = simde_mm256_subs_epi16(bit_met_m1_p3, ch_mag_over_2); + + simde__m256i bit_met_m1_m1 = simde_mm256_subs_epi16(psi_a_m1_m1, a_sq_m1_m1); + bit_met_m1_m1 = simde_mm256_subs_epi16(bit_met_m1_m1, y0_p_1_1); + bit_met_m1_m1 = simde_mm256_subs_epi16(bit_met_m1_m1, ch_mag_over_10); + + simde__m256i bit_met_m1_m3 = simde_mm256_subs_epi16(psi_a_m1_m3, a_sq_m1_m3); + bit_met_m1_m3 = simde_mm256_subs_epi16(bit_met_m1_m3, y0_p_1_3); + bit_met_m1_m3 = simde_mm256_subs_epi16(bit_met_m1_m3, ch_mag_over_2); + + simde__m256i bit_met_m3_p1 = simde_mm256_subs_epi16(psi_a_m3_p1, a_sq_m3_p1); + bit_met_m3_p1 = simde_mm256_subs_epi16(bit_met_m3_p1, y0_m_3_1); + bit_met_m3_p1 = simde_mm256_subs_epi16(bit_met_m3_p1, ch_mag_over_2); + + simde__m256i bit_met_m3_p3 = simde_mm256_subs_epi16(psi_a_m3_p3, a_sq_m3_p3); + bit_met_m3_p3 = simde_mm256_subs_epi16(bit_met_m3_p3, y0_m_3_3); + bit_met_m3_p3 = simde_mm256_subs_epi16(bit_met_m3_p3, ch_mag_9_over_10); + + simde__m256i bit_met_m3_m1 = simde_mm256_subs_epi16(psi_a_m3_m1, a_sq_m3_m1); + bit_met_m3_m1 = simde_mm256_subs_epi16(bit_met_m3_m1, y0_p_3_1); + bit_met_m3_m1 = simde_mm256_subs_epi16(bit_met_m3_m1, ch_mag_over_2); + + simde__m256i bit_met_m3_m3 = simde_mm256_subs_epi16(psi_a_m3_m3, a_sq_m3_m3); + bit_met_m3_m3 = simde_mm256_subs_epi16(bit_met_m3_m3, y0_p_3_3); + bit_met_m3_m3 = simde_mm256_subs_epi16(bit_met_m3_m3, ch_mag_9_over_10); + + /// Compute the LLRs + + // LLR = lambda(c==1) - lambda(c==0) + + // LLR of the first bit: Bit = 1 + simde__m256i logmax_num_re0 = max_epi16_256(bit_met_m1_p1, + bit_met_m1_p3, + bit_met_m1_m1, + bit_met_m1_m3, + bit_met_m3_p1, + bit_met_m3_p3, + bit_met_m3_m1, + bit_met_m3_m3); + + // LLR of the first bit: Bit = 0 + simde__m256i logmax_den_re0 = max_epi16_256(bit_met_p1_p1, + bit_met_p1_p3, + bit_met_p1_m1, + bit_met_p1_m3, + bit_met_p3_p1, + bit_met_p3_p3, + bit_met_p3_m1, + bit_met_p3_m3); + + // LLR of the second bit: Bit = 1 + simde__m256i logmax_num_re1 = max_epi16_256(bit_met_p1_m1, + bit_met_p3_m1, + bit_met_m1_m1, + bit_met_m3_m1, + bit_met_p1_m3, + bit_met_p3_m3, + bit_met_m1_m3, + bit_met_m3_m3); + + // LLR of the second bit: Bit = 0 + simde__m256i logmax_den_re1 = max_epi16_256(bit_met_p1_p1, + bit_met_p3_p1, + bit_met_m1_p1, + bit_met_m3_p1, + bit_met_p1_p3, + bit_met_p3_p3, + bit_met_m1_p3, + bit_met_m3_p3); + + // LLR of the third bit: Bit = 1 + simde__m256i logmax_num_im0 = max_epi16_256(bit_met_m3_p1, + bit_met_m3_p3, + bit_met_m3_m1, + bit_met_m3_m3, + bit_met_p3_p1, + bit_met_p3_p3, + bit_met_p3_m1, + bit_met_p3_m3); + + // LLR of the third bit: Bit = 0 + simde__m256i logmax_den_im0 = max_epi16_256(bit_met_m1_p1, + bit_met_m1_p3, + bit_met_m1_m1, + bit_met_m1_m3, + bit_met_p1_p1, + bit_met_p1_p3, + bit_met_p1_m1, + bit_met_p1_m3); + + // LLR of the fourth bit: Bit = 1 + simde__m256i logmax_num_im1 = max_epi16_256(bit_met_p1_m3, + bit_met_p3_m3, + bit_met_m1_m3, + bit_met_m3_m3, + bit_met_p1_p3, + bit_met_p3_p3, + bit_met_m1_p3, + bit_met_m3_p3); + + // LLR of the fourth bit: Bit = 0 + simde__m256i logmax_den_im1 = max_epi16_256(bit_met_p1_m1, + bit_met_p3_m1, + bit_met_m1_m1, + bit_met_m3_m1, + bit_met_p1_p1, + bit_met_p3_p1, + bit_met_m1_p1, + bit_met_m3_p1); + + y0r = simde_mm256_subs_epi16(logmax_den_re0, logmax_num_re0); // LLR of first bit [L1(1), L1(2), L1(3), L1(4), L1(5), L1(6), L1(7), L1(8)...] + y1r = simde_mm256_subs_epi16(logmax_den_re1, logmax_num_re1); // LLR of second bit [L2(1), L2(2), L2(3), L2(4), L2(5), L2(6), L2(7), L2(8)...] + y0i = simde_mm256_subs_epi16(logmax_den_im0, logmax_num_im0); // LLR of third bit [L3(1), L3(2), L3(3), L3(4), L3(5), L3(6), L3(7), L3(8)...] + y1i = simde_mm256_subs_epi16(logmax_den_im1, logmax_num_im1); // LLR of fourth bit [L4(1), L4(2), L4(3), L4(4), L4(5), L4(6), L4(7), L4(8)...] + + // Pack LLRs in output + simde__m128i* y0r_128 = (simde__m128i *) &y0r; + simde__m128i* y1r_128 = (simde__m128i *) &y1r; + simde__m128i* y0i_128 = (simde__m128i *) &y0i; + simde__m128i* y1i_128 = (simde__m128i *) &y1i; + simde__m128i xmm0_128, xmm1_128, xmm2_128, xmm3_128; + xmm0_128 = simde_mm_unpacklo_epi16(y0r_128[0], y1r_128[0]); // [L1(1), L2(1), L1(2), L2(2), L1(3), L2(3), L1(4), L2(4)] + xmm1_128 = simde_mm_unpackhi_epi16(y0r_128[0], y1r_128[0]); // [L1(5), L2(5), L1(6), L2(6), L1(7), L2(7), L1(8), L2(8)] + xmm2_128 = simde_mm_unpacklo_epi16(y0i_128[0], y1i_128[0]); // [L3(1), L4(1), L3(2), L4(2), L3(3), L4(3), L3(4), L4(4)] + xmm3_128 = simde_mm_unpackhi_epi16(y0i_128[0], y1i_128[0]); // [L3(5), L4(5), L3(6), L4(6), L3(7), L4(7), L3(8), L4(8)] + simde__m128i* stream0_128i_out = (simde__m128i *) &stream0_256i_out[2 * i + 0]; + stream0_128i_out[0] = simde_mm_unpacklo_epi32(xmm0_128, xmm2_128); // 8 LLRs, 2 REs + stream0_128i_out[1] = simde_mm_unpackhi_epi32(xmm0_128, xmm2_128); // 8 LLRs, 2 REs + stream0_128i_out[2] = simde_mm_unpacklo_epi32(xmm1_128, xmm3_128); // 8 LLRs, 2 REs + stream0_128i_out[3] = simde_mm_unpackhi_epi32(xmm1_128, xmm3_128); // 8 LLRs, 2 REs + xmm0_128 = simde_mm_unpacklo_epi16(y0r_128[1], y1r_128[1]); // [L1(9), L2(9), L1(10), L2(10), L1(11), L2(11), L1(12), L2(12)] + xmm1_128 = simde_mm_unpackhi_epi16(y0r_128[1], y1r_128[1]); // [L1(13), L2(13), L1(14), L2(14), L1(15), L2(15), L1(16), L2(16)] + xmm2_128 = simde_mm_unpacklo_epi16(y0i_128[1], y1i_128[1]); // [L3(9), L4(9), L3(10), L4(10), L3(11), L4(11), L3(12), L4(12)] + xmm3_128 = simde_mm_unpackhi_epi16(y0i_128[1], y1i_128[1]); // [L3(13), L4(13), L3(14), L4(14), L3(15), L4(15), L3(16), L4(16)] + stream0_128i_out = (simde__m128i *) &stream0_256i_out[2 * i + 2]; + stream0_128i_out[0] = simde_mm_unpacklo_epi32(xmm0_128, xmm2_128); // 8 LLRs, 2 REs + stream0_128i_out[1] = simde_mm_unpackhi_epi32(xmm0_128, xmm2_128); // 8 LLRs, 2 REs + stream0_128i_out[2] = simde_mm_unpacklo_epi32(xmm1_128, xmm3_128); // 8 LLRs, 2 REs + stream0_128i_out[3] = simde_mm_unpackhi_epi32(xmm1_128, xmm3_128); // 8 LLRs, 2 REs + } +#endif simde_mm_empty(); simde_m_empty(); } -static const int16_t ones256[16] __attribute__((aligned(32))) = {0xffff, - 0xffff, - 0xffff, - 0xffff, - 0xffff, - 0xffff, - 0xffff, - 0xffff, - 0xffff, - 0xffff, - 0xffff, - 0xffff, - 0xffff, - 0xffff, - 0xffff, - 0xffff}; - -/// Auxiliary Makros - -// calculate interference magnitude -// tmp_result = ones in shorts corr. to interval 2<=x<=4, tmp_result2 interval < 2, tmp_result3 interval 46 -#define interference_abs_64qam_epi16_256(psi, int_ch_mag, int_two_ch_mag, int_three_ch_mag, a, c1, c3, c5, c7) \ - tmp_result = simde_mm256_cmpgt_epi16(int_two_ch_mag, psi); \ - tmp_result3 = simde_mm256_xor_si256(tmp_result, (*(simde__m256i *)&ones256[0])); \ - tmp_result2 = simde_mm256_cmpgt_epi16(int_ch_mag, psi); \ - tmp_result = simde_mm256_xor_si256(tmp_result, tmp_result2); \ - tmp_result4 = simde_mm256_cmpgt_epi16(psi, int_three_ch_mag); \ - tmp_result3 = simde_mm256_xor_si256(tmp_result3, tmp_result4); \ - tmp_result = simde_mm256_and_si256(tmp_result, c3); \ - tmp_result2 = simde_mm256_and_si256(tmp_result2, c1); \ - tmp_result3 = simde_mm256_and_si256(tmp_result3, c5); \ - tmp_result4 = simde_mm256_and_si256(tmp_result4, c7); \ - tmp_result = simde_mm256_or_si256(tmp_result, tmp_result2); \ - tmp_result3 = simde_mm256_or_si256(tmp_result3, tmp_result4); \ - const simde__m256i a = simde_mm256_or_si256(tmp_result, tmp_result3); - -// calculates psi_a = psi_r*a_r + psi_i*a_i -#define prodsum_psi_a_epi16_256(psi_r, a_r, psi_i, a_i, psi_a) \ - tmp_result = simde_mm256_mulhi_epi16(psi_r, a_r); \ - tmp_result = simde_mm256_slli_epi16(tmp_result, 1); \ - tmp_result2 = simde_mm256_mulhi_epi16(psi_i, a_i); \ - tmp_result2 = simde_mm256_slli_epi16(tmp_result2, 1); \ - simde__m256i psi_a = simde_mm256_adds_epi16(tmp_result, tmp_result2); - -// calculates a_sq = int_ch_mag*(a_r^2 + a_i^2)*scale_factor for 64-QAM -#define square_a_64qam_epi16_256(a_r, a_i, int_ch_mag, scale_factor, a_sq) \ - tmp_result = simde_mm256_mulhi_epi16(a_r, a_r); \ - tmp_result = simde_mm256_slli_epi16(tmp_result, 1); \ - tmp_result = simde_mm256_mulhi_epi16(tmp_result, scale_factor); \ - tmp_result = simde_mm256_slli_epi16(tmp_result, 3); \ - tmp_result = simde_mm256_mulhi_epi16(tmp_result, int_ch_mag); \ - tmp_result = simde_mm256_slli_epi16(tmp_result, 1); \ - tmp_result2 = simde_mm256_mulhi_epi16(a_i, a_i); \ - tmp_result2 = simde_mm256_slli_epi16(tmp_result2, 1); \ - tmp_result2 = simde_mm256_mulhi_epi16(tmp_result2, scale_factor); \ - tmp_result2 = simde_mm256_slli_epi16(tmp_result2, 3); \ - tmp_result2 = simde_mm256_mulhi_epi16(tmp_result2, int_ch_mag); \ - tmp_result2 = simde_mm256_slli_epi16(tmp_result2, 1); \ - const simde__m256i a_sq = simde_mm256_adds_epi16(tmp_result, tmp_result2); - /* * This function computes the LLRs of stream 0 (s_0) in presence of the interfering stream 1 (s_1) assuming that both symbols are * 64QAM. It can be used for both MU-MIMO interference-aware receiver or for SU-MIMO receivers. @@ -1102,6 +1885,2516 @@ void nr_ulsch_qam64_qam64(c16_t *stream0_in, c16_t *rho01, uint32_t length) { +#ifdef USE_128BIT + simde__m128i *rho01_256i = (simde__m128i *)rho01; + simde__m128i *stream0_256i_in = (simde__m128i *)stream0_in; + simde__m128i *stream1_256i_in = (simde__m128i *)stream1_in; + simde__m128i *ch_mag_256i = (simde__m128i *)ch_mag; + simde__m128i *ch_mag_256i_i = (simde__m128i *)ch_mag_i; + + simde__m128i ONE_OVER_SQRT_42 = simde_mm_set1_epi16(10112); // round(1/sqrt(42)*2^16) + simde__m128i THREE_OVER_SQRT_42 = simde_mm_set1_epi16(30337); // round(3/sqrt(42)*2^16) + simde__m128i FIVE_OVER_SQRT_42 = simde_mm_set1_epi16(25281); // round(5/sqrt(42)*2^15) + simde__m128i SEVEN_OVER_SQRT_42 = simde_mm_set1_epi16(17697); // round(7/sqrt(42)*2^14) Q2.14 + simde__m128i ONE_OVER_SQRT_2 = simde_mm_set1_epi16(23170); // round(1/sqrt(2)*2^15) + simde__m128i ONE_OVER_SQRT_2_42 = simde_mm_set1_epi16(3575); // round(1/sqrt(2*42)*2^15) + simde__m128i THREE_OVER_SQRT_2_42 = simde_mm_set1_epi16(10726); // round(3/sqrt(2*42)*2^15) + simde__m128i FIVE_OVER_SQRT_2_42 = simde_mm_set1_epi16(17876); // round(5/sqrt(2*42)*2^15) + simde__m128i SEVEN_OVER_SQRT_2_42 = simde_mm_set1_epi16(25027); // round(7/sqrt(2*42)*2^15) + simde__m128i FORTYNINE_OVER_FOUR_SQRT_42 = simde_mm_set1_epi16(30969); // round(49/(4*sqrt(42))*2^14), Q2.14 + simde__m128i THIRTYSEVEN_OVER_FOUR_SQRT_42 = simde_mm_set1_epi16(23385); // round(37/(4*sqrt(42))*2^14), Q2.14 + simde__m128i TWENTYFIVE_OVER_FOUR_SQRT_42 = simde_mm_set1_epi16(31601); // round(25/(4*sqrt(42))*2^15) + simde__m128i TWENTYNINE_OVER_FOUR_SQRT_42 = simde_mm_set1_epi16(18329); // round(29/(4*sqrt(42))*2^15), Q2.14 + simde__m128i SEVENTEEN_OVER_FOUR_SQRT_42 = simde_mm_set1_epi16(21489); // round(17/(4*sqrt(42))*2^15) + simde__m128i NINE_OVER_FOUR_SQRT_42 = simde_mm_set1_epi16(11376); // round(9/(4*sqrt(42))*2^15) + simde__m128i THIRTEEN_OVER_FOUR_SQRT_42 = simde_mm_set1_epi16(16433); // round(13/(4*sqrt(42))*2^15) + simde__m128i FIVE_OVER_FOUR_SQRT_42 = simde_mm_set1_epi16(6320); // round(5/(4*sqrt(42))*2^15) + simde__m128i ONE_OVER_FOUR_SQRT_42 = simde_mm_set1_epi16(1264); // round(1/(4*sqrt(42))*2^15) + simde__m128i SQRT_42_OVER_FOUR = simde_mm_set1_epi16(13272); // round(sqrt(42)/4*2^13), Q3.12 + + simde__m128i ch_mag_des; + simde__m128i ch_mag_int; + simde__m128i ch_mag_98_over_42_with_sigma2; + simde__m128i ch_mag_74_over_42_with_sigma2; + simde__m128i ch_mag_58_over_42_with_sigma2; + simde__m128i ch_mag_50_over_42_with_sigma2; + simde__m128i ch_mag_34_over_42_with_sigma2; + simde__m128i ch_mag_18_over_42_with_sigma2; + simde__m128i ch_mag_26_over_42_with_sigma2; + simde__m128i ch_mag_10_over_42_with_sigma2; + simde__m128i ch_mag_2_over_42_with_sigma2; + simde__m128i y0r_one_over_sqrt_21; + simde__m128i y0r_three_over_sqrt_21; + simde__m128i y0r_five_over_sqrt_21; + simde__m128i y0r_seven_over_sqrt_21; + simde__m128i y0i_one_over_sqrt_21; + simde__m128i y0i_three_over_sqrt_21; + simde__m128i y0i_five_over_sqrt_21; + simde__m128i y0i_seven_over_sqrt_21; + simde__m128i ch_mag_int_with_sigma2; + simde__m128i two_ch_mag_int_with_sigma2; + simde__m128i three_ch_mag_int_with_sigma2; + + for (int i = 0; i < length >> 2; i += 2) { + + // Get rho + simde__m128i xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8; + simde_mm128_separate_real_imag_parts(&xmm2, &xmm3, rho01_256i[i], rho01_256i[i + 1]); + + simde__m128i rho_rpi = simde_mm_adds_epi16(xmm2, xmm3); // rho = Re(rho) + Im(rho) + simde__m128i rho_rmi = simde_mm_subs_epi16(xmm2, xmm3); // rho* = Re(rho) - Im(rho) + + // Compute the different rhos + simde__m128i rho_rpi_1_1 = simde_mm_mulhi_epi16(rho_rpi, ONE_OVER_SQRT_42); + simde__m128i rho_rmi_1_1 = simde_mm_mulhi_epi16(rho_rmi, ONE_OVER_SQRT_42); + simde__m128i rho_rpi_3_3 = simde_mm_mulhi_epi16(rho_rpi, THREE_OVER_SQRT_42); + simde__m128i rho_rmi_3_3 = simde_mm_mulhi_epi16(rho_rmi, THREE_OVER_SQRT_42); + simde__m128i rho_rpi_5_5 = simde_mm_mulhi_epi16(rho_rpi, FIVE_OVER_SQRT_42); + simde__m128i rho_rmi_5_5 = simde_mm_mulhi_epi16(rho_rmi, FIVE_OVER_SQRT_42); + simde__m128i rho_rpi_7_7 = simde_mm_mulhi_epi16(rho_rpi, SEVEN_OVER_SQRT_42); + simde__m128i rho_rmi_7_7 = simde_mm_mulhi_epi16(rho_rmi, SEVEN_OVER_SQRT_42); + + rho_rpi_5_5 = simde_mm_slli_epi16(rho_rpi_5_5, 1); + rho_rmi_5_5 = simde_mm_slli_epi16(rho_rmi_5_5, 1); + rho_rpi_7_7 = simde_mm_slli_epi16(rho_rpi_7_7, 2); + rho_rmi_7_7 = simde_mm_slli_epi16(rho_rmi_7_7, 2); + + xmm4 = simde_mm_mulhi_epi16(xmm2, ONE_OVER_SQRT_42); + xmm5 = simde_mm_mulhi_epi16(xmm3, ONE_OVER_SQRT_42); + xmm6 = simde_mm_mulhi_epi16(xmm3, THREE_OVER_SQRT_42); + xmm7 = simde_mm_mulhi_epi16(xmm3, FIVE_OVER_SQRT_42); + xmm8 = simde_mm_mulhi_epi16(xmm3, SEVEN_OVER_SQRT_42); + xmm7 = simde_mm_slli_epi16(xmm7, 1); + xmm8 = simde_mm_slli_epi16(xmm8, 2); + + simde__m128i rho_rpi_1_3 = simde_mm_adds_epi16(xmm4, xmm6); + simde__m128i rho_rmi_1_3 = simde_mm_subs_epi16(xmm4, xmm6); + simde__m128i rho_rpi_1_5 = simde_mm_adds_epi16(xmm4, xmm7); + simde__m128i rho_rmi_1_5 = simde_mm_subs_epi16(xmm4, xmm7); + simde__m128i rho_rpi_1_7 = simde_mm_adds_epi16(xmm4, xmm8); + simde__m128i rho_rmi_1_7 = simde_mm_subs_epi16(xmm4, xmm8); + + xmm4 = simde_mm_mulhi_epi16(xmm2, THREE_OVER_SQRT_42); + simde__m128i rho_rpi_3_1 = simde_mm_adds_epi16(xmm4, xmm5); + simde__m128i rho_rmi_3_1 = simde_mm_subs_epi16(xmm4, xmm5); + simde__m128i rho_rpi_3_5 = simde_mm_adds_epi16(xmm4, xmm7); + simde__m128i rho_rmi_3_5 = simde_mm_subs_epi16(xmm4, xmm7); + simde__m128i rho_rpi_3_7 = simde_mm_adds_epi16(xmm4, xmm8); + simde__m128i rho_rmi_3_7 = simde_mm_subs_epi16(xmm4, xmm8); + + xmm4 = simde_mm_mulhi_epi16(xmm2, FIVE_OVER_SQRT_42); + xmm4 = simde_mm_slli_epi16(xmm4, 1); + simde__m128i rho_rpi_5_1 = simde_mm_adds_epi16(xmm4, xmm5); + simde__m128i rho_rmi_5_1 = simde_mm_subs_epi16(xmm4, xmm5); + simde__m128i rho_rpi_5_3 = simde_mm_adds_epi16(xmm4, xmm6); + simde__m128i rho_rmi_5_3 = simde_mm_subs_epi16(xmm4, xmm6); + simde__m128i rho_rpi_5_7 = simde_mm_adds_epi16(xmm4, xmm8); + simde__m128i rho_rmi_5_7 = simde_mm_subs_epi16(xmm4, xmm8); + + xmm4 = simde_mm_mulhi_epi16(xmm2, SEVEN_OVER_SQRT_42); + xmm4 = simde_mm_slli_epi16(xmm4, 2); + simde__m128i rho_rpi_7_1 = simde_mm_adds_epi16(xmm4, xmm5); + simde__m128i rho_rmi_7_1 = simde_mm_subs_epi16(xmm4, xmm5); + simde__m128i rho_rpi_7_3 = simde_mm_adds_epi16(xmm4, xmm6); + simde__m128i rho_rmi_7_3 = simde_mm_subs_epi16(xmm4, xmm6); + simde__m128i rho_rpi_7_5 = simde_mm_adds_epi16(xmm4, xmm7); + simde__m128i rho_rmi_7_5 = simde_mm_subs_epi16(xmm4, xmm7); + + // Rearrange interfering MF output + simde__m128i y1r, y1i, xmm0; + simde_mm128_separate_real_imag_parts(&y1r, &y1i, stream1_256i_in[i], stream1_256i_in[i + 1]); + + // Psi_r calculation from rho_rpi or rho_rmi + xmm0 = simde_mm_set1_epi16(0); // ZERO for abs_pi16 + xmm2 = simde_mm_subs_epi16(rho_rpi_7_7, y1r); + + simde__m128i psi_r_p7_p7 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rpi_7_5, y1r); + simde__m128i psi_r_p7_p5 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rpi_7_3, y1r); + simde__m128i psi_r_p7_p3 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rpi_7_1, y1r); + simde__m128i psi_r_p7_p1 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rmi_7_1, y1r); + simde__m128i psi_r_p7_m1 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rmi_7_3, y1r); + simde__m128i psi_r_p7_m3 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rmi_7_5, y1r); + simde__m128i psi_r_p7_m5 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rmi_7_7, y1r); + simde__m128i psi_r_p7_m7 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rpi_5_7, y1r); + simde__m128i psi_r_p5_p7 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rpi_5_5, y1r); + simde__m128i psi_r_p5_p5 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rpi_5_3, y1r); + simde__m128i psi_r_p5_p3 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rpi_5_1, y1r); + simde__m128i psi_r_p5_p1 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rmi_5_1, y1r); + simde__m128i psi_r_p5_m1 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rmi_5_3, y1r); + simde__m128i psi_r_p5_m3 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rmi_5_5, y1r); + simde__m128i psi_r_p5_m5 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rmi_5_7, y1r); + simde__m128i psi_r_p5_m7 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rpi_3_7, y1r); + simde__m128i psi_r_p3_p7 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rpi_3_5, y1r); + simde__m128i psi_r_p3_p5 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rpi_3_3, y1r); + simde__m128i psi_r_p3_p3 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rpi_3_1, y1r); + simde__m128i psi_r_p3_p1 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rmi_3_1, y1r); + simde__m128i psi_r_p3_m1 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rmi_3_3, y1r); + simde__m128i psi_r_p3_m3 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rmi_3_5, y1r); + simde__m128i psi_r_p3_m5 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rmi_3_7, y1r); + simde__m128i psi_r_p3_m7 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rpi_1_7, y1r); + simde__m128i psi_r_p1_p7 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rpi_1_5, y1r); + simde__m128i psi_r_p1_p5 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rpi_1_3, y1r); + simde__m128i psi_r_p1_p3 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rpi_1_1, y1r); + simde__m128i psi_r_p1_p1 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rmi_1_1, y1r); + simde__m128i psi_r_p1_m1 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rmi_1_3, y1r); + simde__m128i psi_r_p1_m3 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rmi_1_5, y1r); + simde__m128i psi_r_p1_m5 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rmi_1_7, y1r); + simde__m128i psi_r_p1_m7 = simde_mm_abs_epi16(xmm2); + + xmm2 = simde_mm_adds_epi16(rho_rmi_1_7, y1r); + simde__m128i psi_r_m1_p7 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rmi_1_5, y1r); + simde__m128i psi_r_m1_p5 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rmi_1_3, y1r); + simde__m128i psi_r_m1_p3 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rmi_1_1, y1r); + simde__m128i psi_r_m1_p1 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rpi_1_1, y1r); + simde__m128i psi_r_m1_m1 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rpi_1_3, y1r); + simde__m128i psi_r_m1_m3 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rpi_1_5, y1r); + simde__m128i psi_r_m1_m5 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rpi_1_7, y1r); + simde__m128i psi_r_m1_m7 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rmi_3_7, y1r); + simde__m128i psi_r_m3_p7 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rmi_3_5, y1r); + simde__m128i psi_r_m3_p5 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rmi_3_3, y1r); + simde__m128i psi_r_m3_p3 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rmi_3_1, y1r); + simde__m128i psi_r_m3_p1 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rpi_3_1, y1r); + simde__m128i psi_r_m3_m1 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rpi_3_3, y1r); + simde__m128i psi_r_m3_m3 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rpi_3_5, y1r); + simde__m128i psi_r_m3_m5 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rpi_3_7, y1r); + simde__m128i psi_r_m3_m7 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rmi_5_7, y1r); + simde__m128i psi_r_m5_p7 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rmi_5_5, y1r); + simde__m128i psi_r_m5_p5 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rmi_5_3, y1r); + simde__m128i psi_r_m5_p3 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rmi_5_1, y1r); + simde__m128i psi_r_m5_p1 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rpi_5_1, y1r); + simde__m128i psi_r_m5_m1 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rpi_5_3, y1r); + simde__m128i psi_r_m5_m3 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rpi_5_5, y1r); + simde__m128i psi_r_m5_m5 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rpi_5_7, y1r); + simde__m128i psi_r_m5_m7 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rmi_7_7, y1r); + simde__m128i psi_r_m7_p7 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rmi_7_5, y1r); + simde__m128i psi_r_m7_p5 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rmi_7_3, y1r); + simde__m128i psi_r_m7_p3 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rmi_7_1, y1r); + simde__m128i psi_r_m7_p1 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rpi_7_1, y1r); + simde__m128i psi_r_m7_m1 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rpi_7_3, y1r); + simde__m128i psi_r_m7_m3 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rpi_7_5, y1r); + simde__m128i psi_r_m7_m5 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rpi_7_7, y1r); + simde__m128i psi_r_m7_m7 = simde_mm_abs_epi16(xmm2); + + // simde__m128i Psi_i calculation from rho_rpi or rho_rmi + xmm2 = simde_mm_subs_epi16(rho_rmi_7_7, y1i); + simde__m128i psi_i_p7_p7 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rmi_5_7, y1i); + simde__m128i psi_i_p7_p5 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rmi_3_7, y1i); + simde__m128i psi_i_p7_p3 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rmi_1_7, y1i); + simde__m128i psi_i_p7_p1 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rpi_1_7, y1i); + simde__m128i psi_i_p7_m1 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rpi_3_7, y1i); + simde__m128i psi_i_p7_m3 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rpi_5_7, y1i); + simde__m128i psi_i_p7_m5 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rpi_7_7, y1i); + simde__m128i psi_i_p7_m7 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rmi_7_5, y1i); + simde__m128i psi_i_p5_p7 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rmi_5_5, y1i); + simde__m128i psi_i_p5_p5 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rmi_3_5, y1i); + simde__m128i psi_i_p5_p3 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rmi_1_5, y1i); + simde__m128i psi_i_p5_p1 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rpi_1_5, y1i); + simde__m128i psi_i_p5_m1 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rpi_3_5, y1i); + simde__m128i psi_i_p5_m3 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rpi_5_5, y1i); + simde__m128i psi_i_p5_m5 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rpi_7_5, y1i); + simde__m128i psi_i_p5_m7 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rmi_7_3, y1i); + simde__m128i psi_i_p3_p7 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rmi_5_3, y1i); + simde__m128i psi_i_p3_p5 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rmi_3_3, y1i); + simde__m128i psi_i_p3_p3 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rmi_1_3, y1i); + simde__m128i psi_i_p3_p1 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rpi_1_3, y1i); + simde__m128i psi_i_p3_m1 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rpi_3_3, y1i); + simde__m128i psi_i_p3_m3 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rpi_5_3, y1i); + simde__m128i psi_i_p3_m5 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rpi_7_3, y1i); + simde__m128i psi_i_p3_m7 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rmi_7_1, y1i); + simde__m128i psi_i_p1_p7 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rmi_5_1, y1i); + simde__m128i psi_i_p1_p5 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rmi_3_1, y1i); + simde__m128i psi_i_p1_p3 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rmi_1_1, y1i); + simde__m128i psi_i_p1_p1 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rpi_1_1, y1i); + simde__m128i psi_i_p1_m1 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rpi_3_1, y1i); + simde__m128i psi_i_p1_m3 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rpi_5_1, y1i); + simde__m128i psi_i_p1_m5 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rpi_7_1, y1i); + simde__m128i psi_i_p1_m7 = simde_mm_abs_epi16(xmm2); + + xmm2 = simde_mm_subs_epi16(rho_rpi_7_1, y1i); + simde__m128i psi_i_m1_p7 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rpi_5_1, y1i); + simde__m128i psi_i_m1_p5 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rpi_3_1, y1i); + simde__m128i psi_i_m1_p3 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rpi_1_1, y1i); + simde__m128i psi_i_m1_p1 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rmi_1_1, y1i); + simde__m128i psi_i_m1_m1 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rmi_3_1, y1i); + simde__m128i psi_i_m1_m3 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rmi_5_1, y1i); + simde__m128i psi_i_m1_m5 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rmi_7_1, y1i); + simde__m128i psi_i_m1_m7 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rpi_7_3, y1i); + simde__m128i psi_i_m3_p7 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rpi_5_3, y1i); + simde__m128i psi_i_m3_p5 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rpi_3_3, y1i); + simde__m128i psi_i_m3_p3 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rpi_1_3, y1i); + simde__m128i psi_i_m3_p1 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rmi_1_3, y1i); + simde__m128i psi_i_m3_m1 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rmi_3_3, y1i); + simde__m128i psi_i_m3_m3 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rmi_5_3, y1i); + simde__m128i psi_i_m3_m5 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rmi_7_3, y1i); + simde__m128i psi_i_m3_m7 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rpi_7_5, y1i); + simde__m128i psi_i_m5_p7 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rpi_5_5, y1i); + simde__m128i psi_i_m5_p5 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rpi_3_5, y1i); + simde__m128i psi_i_m5_p3 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rpi_1_5, y1i); + simde__m128i psi_i_m5_p1 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rmi_1_5, y1i); + simde__m128i psi_i_m5_m1 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rmi_3_5, y1i); + simde__m128i psi_i_m5_m3 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rmi_5_5, y1i); + simde__m128i psi_i_m5_m5 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rmi_7_5, y1i); + simde__m128i psi_i_m5_m7 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rpi_7_7, y1i); + simde__m128i psi_i_m7_p7 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rpi_5_7, y1i); + simde__m128i psi_i_m7_p5 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rpi_3_7, y1i); + simde__m128i psi_i_m7_p3 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_subs_epi16(rho_rpi_1_7, y1i); + simde__m128i psi_i_m7_p1 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rmi_1_7, y1i); + simde__m128i psi_i_m7_m1 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rmi_3_7, y1i); + simde__m128i psi_i_m7_m3 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rmi_5_7, y1i); + simde__m128i psi_i_m7_m5 = simde_mm_abs_epi16(xmm2); + xmm2 = simde_mm_adds_epi16(rho_rmi_7_7, y1i); + simde__m128i psi_i_m7_m7 = simde_mm_abs_epi16(xmm2); + + // Rearrange desired MF output + simde__m128i y0r, y0i; + simde_mm128_separate_real_imag_parts(&y0r, &y0i, stream0_256i_in[i], stream0_256i_in[i + 1]); + + // Rearrange desired channel magnitudes + // [|h|^2(1),|h|^2(1),|h|^2(2),|h|^2(2),...,,|h|^2(7),|h|^2(7)]*(2/sqrt(10)) + // xmm2 is dummy variable that contains the same values as ch_mag_des + simde_mm128_separate_real_imag_parts(&ch_mag_des, &xmm2, ch_mag_256i[i], ch_mag_256i[i + 1]); + + // Rearrange interfering channel magnitudes + simde_mm128_separate_real_imag_parts(&ch_mag_int, &xmm2, ch_mag_256i_i[i], ch_mag_256i_i[i + 1]); + + y0r_one_over_sqrt_21 = simde_mm_mulhi_epi16(y0r, ONE_OVER_SQRT_42); + y0r_three_over_sqrt_21 = simde_mm_mulhi_epi16(y0r, THREE_OVER_SQRT_42); + y0r_five_over_sqrt_21 = simde_mm_mulhi_epi16(y0r, FIVE_OVER_SQRT_42); + y0r_five_over_sqrt_21 = simde_mm_slli_epi16(y0r_five_over_sqrt_21, 1); + y0r_seven_over_sqrt_21 = simde_mm_mulhi_epi16(y0r, SEVEN_OVER_SQRT_42); + y0r_seven_over_sqrt_21 = simde_mm_slli_epi16(y0r_seven_over_sqrt_21, 2); // Q2.14 + + y0i_one_over_sqrt_21 = simde_mm_mulhi_epi16(y0i, ONE_OVER_SQRT_42); + y0i_three_over_sqrt_21 = simde_mm_mulhi_epi16(y0i, THREE_OVER_SQRT_42); + y0i_five_over_sqrt_21 = simde_mm_mulhi_epi16(y0i, FIVE_OVER_SQRT_42); + y0i_five_over_sqrt_21 = simde_mm_slli_epi16(y0i_five_over_sqrt_21, 1); + y0i_seven_over_sqrt_21 = simde_mm_mulhi_epi16(y0i, SEVEN_OVER_SQRT_42); + y0i_seven_over_sqrt_21 = simde_mm_slli_epi16(y0i_seven_over_sqrt_21, 2); // Q2.14 + + simde__m128i y0_p_7_1 = simde_mm_adds_epi16(y0r_seven_over_sqrt_21, y0i_one_over_sqrt_21); + simde__m128i y0_p_7_3 = simde_mm_adds_epi16(y0r_seven_over_sqrt_21, y0i_three_over_sqrt_21); + simde__m128i y0_p_7_5 = simde_mm_adds_epi16(y0r_seven_over_sqrt_21, y0i_five_over_sqrt_21); + simde__m128i y0_p_7_7 = simde_mm_adds_epi16(y0r_seven_over_sqrt_21, y0i_seven_over_sqrt_21); + simde__m128i y0_p_5_1 = simde_mm_adds_epi16(y0r_five_over_sqrt_21, y0i_one_over_sqrt_21); + simde__m128i y0_p_5_3 = simde_mm_adds_epi16(y0r_five_over_sqrt_21, y0i_three_over_sqrt_21); + simde__m128i y0_p_5_5 = simde_mm_adds_epi16(y0r_five_over_sqrt_21, y0i_five_over_sqrt_21); + simde__m128i y0_p_5_7 = simde_mm_adds_epi16(y0r_five_over_sqrt_21, y0i_seven_over_sqrt_21); + simde__m128i y0_p_3_1 = simde_mm_adds_epi16(y0r_three_over_sqrt_21, y0i_one_over_sqrt_21); + simde__m128i y0_p_3_3 = simde_mm_adds_epi16(y0r_three_over_sqrt_21, y0i_three_over_sqrt_21); + simde__m128i y0_p_3_5 = simde_mm_adds_epi16(y0r_three_over_sqrt_21, y0i_five_over_sqrt_21); + simde__m128i y0_p_3_7 = simde_mm_adds_epi16(y0r_three_over_sqrt_21, y0i_seven_over_sqrt_21); + simde__m128i y0_p_1_1 = simde_mm_adds_epi16(y0r_one_over_sqrt_21, y0i_one_over_sqrt_21); + simde__m128i y0_p_1_3 = simde_mm_adds_epi16(y0r_one_over_sqrt_21, y0i_three_over_sqrt_21); + simde__m128i y0_p_1_5 = simde_mm_adds_epi16(y0r_one_over_sqrt_21, y0i_five_over_sqrt_21); + simde__m128i y0_p_1_7 = simde_mm_adds_epi16(y0r_one_over_sqrt_21, y0i_seven_over_sqrt_21); + + simde__m128i y0_m_1_1 = simde_mm_subs_epi16(y0r_one_over_sqrt_21, y0i_one_over_sqrt_21); + simde__m128i y0_m_1_3 = simde_mm_subs_epi16(y0r_one_over_sqrt_21, y0i_three_over_sqrt_21); + simde__m128i y0_m_1_5 = simde_mm_subs_epi16(y0r_one_over_sqrt_21, y0i_five_over_sqrt_21); + simde__m128i y0_m_1_7 = simde_mm_subs_epi16(y0r_one_over_sqrt_21, y0i_seven_over_sqrt_21); + simde__m128i y0_m_3_1 = simde_mm_subs_epi16(y0r_three_over_sqrt_21, y0i_one_over_sqrt_21); + simde__m128i y0_m_3_3 = simde_mm_subs_epi16(y0r_three_over_sqrt_21, y0i_three_over_sqrt_21); + simde__m128i y0_m_3_5 = simde_mm_subs_epi16(y0r_three_over_sqrt_21, y0i_five_over_sqrt_21); + simde__m128i y0_m_3_7 = simde_mm_subs_epi16(y0r_three_over_sqrt_21, y0i_seven_over_sqrt_21); + simde__m128i y0_m_5_1 = simde_mm_subs_epi16(y0r_five_over_sqrt_21, y0i_one_over_sqrt_21); + simde__m128i y0_m_5_3 = simde_mm_subs_epi16(y0r_five_over_sqrt_21, y0i_three_over_sqrt_21); + simde__m128i y0_m_5_5 = simde_mm_subs_epi16(y0r_five_over_sqrt_21, y0i_five_over_sqrt_21); + simde__m128i y0_m_5_7 = simde_mm_subs_epi16(y0r_five_over_sqrt_21, y0i_seven_over_sqrt_21); + simde__m128i y0_m_7_1 = simde_mm_subs_epi16(y0r_seven_over_sqrt_21, y0i_one_over_sqrt_21); + simde__m128i y0_m_7_3 = simde_mm_subs_epi16(y0r_seven_over_sqrt_21, y0i_three_over_sqrt_21); + simde__m128i y0_m_7_5 = simde_mm_subs_epi16(y0r_seven_over_sqrt_21, y0i_five_over_sqrt_21); + simde__m128i y0_m_7_7 = simde_mm_subs_epi16(y0r_seven_over_sqrt_21, y0i_seven_over_sqrt_21); + + // Detection of interference term + ch_mag_int_with_sigma2 = simde_mm_srai_epi16(ch_mag_int, 1); // *2 + two_ch_mag_int_with_sigma2 = ch_mag_int; // *4 + three_ch_mag_int_with_sigma2 = simde_mm_adds_epi16(ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2); // *6 + simde__m128i tmp_result, tmp_result2, tmp_result3, tmp_result4; + interference_abs_64qam_epi16(psi_r_p7_p7, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_p7_p7, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_p7_p5, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_p7_p5, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_p7_p3, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_p7_p3, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_p7_p1, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_p7_p1, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_p7_m1, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_p7_m1, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_p7_m3, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_p7_m3, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_p7_m5, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_p7_m5, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_p7_m7, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_p7_m7, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_p5_p7, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_p5_p7, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_p5_p5, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_p5_p5, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_p5_p3, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_p5_p3, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_p5_p1, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_p5_p1, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_p5_m1, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_p5_m1, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_p5_m3, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_p5_m3, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_p5_m5, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_p5_m5, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_p5_m7, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_p5_m7, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_p3_p7, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_p3_p7, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_p3_p5, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_p3_p5, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_p3_p3, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_p3_p3, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_p3_p1, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_p3_p1, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_p3_m1, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_p3_m1, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_p3_m3, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_p3_m3, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_p3_m5, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_p3_m5, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_p3_m7, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_p3_m7, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_p1_p7, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_p1_p7, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_p1_p5, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_p1_p5, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_p1_p3, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_p1_p3, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_p1_p1, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_p1_p1, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_p1_m1, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_p1_m1, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_p1_m3, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_p1_m3, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_p1_m5, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_p1_m5, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_p1_m7, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_p1_m7, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_m1_p7, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_m1_p7, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_m1_p5, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_m1_p5, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_m1_p3, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_m1_p3, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_m1_p1, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_m1_p1, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_m1_m1, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_m1_m1, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_m1_m3, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_m1_m3, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_m1_m5, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_m1_m5, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_m1_m7, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_m1_m7, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_m3_p7, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_m3_p7, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_m3_p5, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_m3_p5, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_m3_p3, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_m3_p3, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_m3_p1, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_m3_p1, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_m3_m1, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_m3_m1, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_m3_m3, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_m3_m3, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_m3_m5, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_m3_m5, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_m3_m7, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_m3_m7, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_m5_p7, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_m5_p7, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_m5_p5, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_m5_p5, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_m5_p3, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_m5_p3, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_m5_p1, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_m5_p1, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_m5_m1, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_m5_m1, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_m5_m3, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_m5_m3, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_m5_m5, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_m5_m5, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_m5_m7, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_m5_m7, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_m7_p7, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_m7_p7, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_m7_p5, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_m7_p5, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_m7_p3, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_m7_p3, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_m7_p1, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_m7_p1, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_m7_m1, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_m7_m1, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_m7_m3, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_m7_m3, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_m7_m5, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_m7_m5, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_r_m7_m7, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_r_m7_m7, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + + interference_abs_64qam_epi16(psi_i_p7_p7, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_p7_p7, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_p7_p5, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_p7_p5, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_p7_p3, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_p7_p3, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_p7_p1, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_p7_p1, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_p7_m1, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_p7_m1, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_p7_m3, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_p7_m3, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_p7_m5, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_p7_m5, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_p7_m7, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_p7_m7, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_p5_p7, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_p5_p7, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_p5_p5, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_p5_p5, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_p5_p3, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_p5_p3, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_p5_p1, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_p5_p1, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_p5_m1, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_p5_m1, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_p5_m3, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_p5_m3, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_p5_m5, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_p5_m5, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_p5_m7, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_p5_m7, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_p3_p7, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_p3_p7, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_p3_p5, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_p3_p5, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_p3_p3, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_p3_p3, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_p3_p1, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_p3_p1, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_p3_m1, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_p3_m1, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_p3_m3, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_p3_m3, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_p3_m5, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_p3_m5, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_p3_m7, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_p3_m7, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_p1_p7, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_p1_p7, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_p1_p5, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_p1_p5, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_p1_p3, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_p1_p3, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_p1_p1, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_p1_p1, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_p1_m1, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_p1_m1, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_p1_m3, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_p1_m3, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_p1_m5, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_p1_m5, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_p1_m7, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_p1_m7, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_m1_p7, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_m1_p7, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_m1_p5, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_m1_p5, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_m1_p3, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_m1_p3, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_m1_p1, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_m1_p1, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_m1_m1, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_m1_m1, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_m1_m3, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_m1_m3, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_m1_m5, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_m1_m5, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_m1_m7, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_m1_m7, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_m3_p7, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_m3_p7, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_m3_p5, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_m3_p5, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_m3_p3, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_m3_p3, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_m3_p1, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_m3_p1, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_m3_m1, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_m3_m1, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_m3_m3, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_m3_m3, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_m3_m5, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_m3_m5, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_m3_m7, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_m3_m7, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_m5_p7, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_m5_p7, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_m5_p5, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_m5_p5, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_m5_p3, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_m5_p3, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_m5_p1, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_m5_p1, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_m5_m1, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_m5_m1, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_m5_m3, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_m5_m3, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_m5_m5, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_m5_m5, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_m5_m7, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_m5_m7, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_m7_p7, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_m7_p7, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_m7_p5, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_m7_p5, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_m7_p3, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_m7_p3, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_m7_p1, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_m7_p1, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_m7_m1, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_m7_m1, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_m7_m3, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_m7_m3, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_m7_m5, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_m7_m5, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + interference_abs_64qam_epi16(psi_i_m7_m7, + ch_mag_int_with_sigma2, + two_ch_mag_int_with_sigma2, + three_ch_mag_int_with_sigma2, + a_i_m7_m7, + ONE_OVER_SQRT_2_42, + THREE_OVER_SQRT_2_42, + FIVE_OVER_SQRT_2_42, + SEVEN_OVER_SQRT_2_42); + + // Calculation of a group of two terms in the bit metric involving product of psi and interference + prodsum_psi_a_epi16(psi_r_p7_p7, a_r_p7_p7, psi_i_p7_p7, a_i_p7_p7, psi_a_p7_p7); + prodsum_psi_a_epi16(psi_r_p7_p5, a_r_p7_p5, psi_i_p7_p5, a_i_p7_p5, psi_a_p7_p5); + prodsum_psi_a_epi16(psi_r_p7_p3, a_r_p7_p3, psi_i_p7_p3, a_i_p7_p3, psi_a_p7_p3); + prodsum_psi_a_epi16(psi_r_p7_p1, a_r_p7_p1, psi_i_p7_p1, a_i_p7_p1, psi_a_p7_p1); + prodsum_psi_a_epi16(psi_r_p7_m1, a_r_p7_m1, psi_i_p7_m1, a_i_p7_m1, psi_a_p7_m1); + prodsum_psi_a_epi16(psi_r_p7_m3, a_r_p7_m3, psi_i_p7_m3, a_i_p7_m3, psi_a_p7_m3); + prodsum_psi_a_epi16(psi_r_p7_m5, a_r_p7_m5, psi_i_p7_m5, a_i_p7_m5, psi_a_p7_m5); + prodsum_psi_a_epi16(psi_r_p7_m7, a_r_p7_m7, psi_i_p7_m7, a_i_p7_m7, psi_a_p7_m7); + prodsum_psi_a_epi16(psi_r_p5_p7, a_r_p5_p7, psi_i_p5_p7, a_i_p5_p7, psi_a_p5_p7); + prodsum_psi_a_epi16(psi_r_p5_p5, a_r_p5_p5, psi_i_p5_p5, a_i_p5_p5, psi_a_p5_p5); + prodsum_psi_a_epi16(psi_r_p5_p3, a_r_p5_p3, psi_i_p5_p3, a_i_p5_p3, psi_a_p5_p3); + prodsum_psi_a_epi16(psi_r_p5_p1, a_r_p5_p1, psi_i_p5_p1, a_i_p5_p1, psi_a_p5_p1); + prodsum_psi_a_epi16(psi_r_p5_m1, a_r_p5_m1, psi_i_p5_m1, a_i_p5_m1, psi_a_p5_m1); + prodsum_psi_a_epi16(psi_r_p5_m3, a_r_p5_m3, psi_i_p5_m3, a_i_p5_m3, psi_a_p5_m3); + prodsum_psi_a_epi16(psi_r_p5_m5, a_r_p5_m5, psi_i_p5_m5, a_i_p5_m5, psi_a_p5_m5); + prodsum_psi_a_epi16(psi_r_p5_m7, a_r_p5_m7, psi_i_p5_m7, a_i_p5_m7, psi_a_p5_m7); + prodsum_psi_a_epi16(psi_r_p3_p7, a_r_p3_p7, psi_i_p3_p7, a_i_p3_p7, psi_a_p3_p7); + prodsum_psi_a_epi16(psi_r_p3_p5, a_r_p3_p5, psi_i_p3_p5, a_i_p3_p5, psi_a_p3_p5); + prodsum_psi_a_epi16(psi_r_p3_p3, a_r_p3_p3, psi_i_p3_p3, a_i_p3_p3, psi_a_p3_p3); + prodsum_psi_a_epi16(psi_r_p3_p1, a_r_p3_p1, psi_i_p3_p1, a_i_p3_p1, psi_a_p3_p1); + prodsum_psi_a_epi16(psi_r_p3_m1, a_r_p3_m1, psi_i_p3_m1, a_i_p3_m1, psi_a_p3_m1); + prodsum_psi_a_epi16(psi_r_p3_m3, a_r_p3_m3, psi_i_p3_m3, a_i_p3_m3, psi_a_p3_m3); + prodsum_psi_a_epi16(psi_r_p3_m5, a_r_p3_m5, psi_i_p3_m5, a_i_p3_m5, psi_a_p3_m5); + prodsum_psi_a_epi16(psi_r_p3_m7, a_r_p3_m7, psi_i_p3_m7, a_i_p3_m7, psi_a_p3_m7); + prodsum_psi_a_epi16(psi_r_p1_p7, a_r_p1_p7, psi_i_p1_p7, a_i_p1_p7, psi_a_p1_p7); + prodsum_psi_a_epi16(psi_r_p1_p5, a_r_p1_p5, psi_i_p1_p5, a_i_p1_p5, psi_a_p1_p5); + prodsum_psi_a_epi16(psi_r_p1_p3, a_r_p1_p3, psi_i_p1_p3, a_i_p1_p3, psi_a_p1_p3); + prodsum_psi_a_epi16(psi_r_p1_p1, a_r_p1_p1, psi_i_p1_p1, a_i_p1_p1, psi_a_p1_p1); + prodsum_psi_a_epi16(psi_r_p1_m1, a_r_p1_m1, psi_i_p1_m1, a_i_p1_m1, psi_a_p1_m1); + prodsum_psi_a_epi16(psi_r_p1_m3, a_r_p1_m3, psi_i_p1_m3, a_i_p1_m3, psi_a_p1_m3); + prodsum_psi_a_epi16(psi_r_p1_m5, a_r_p1_m5, psi_i_p1_m5, a_i_p1_m5, psi_a_p1_m5); + prodsum_psi_a_epi16(psi_r_p1_m7, a_r_p1_m7, psi_i_p1_m7, a_i_p1_m7, psi_a_p1_m7); + prodsum_psi_a_epi16(psi_r_m1_p7, a_r_m1_p7, psi_i_m1_p7, a_i_m1_p7, psi_a_m1_p7); + prodsum_psi_a_epi16(psi_r_m1_p5, a_r_m1_p5, psi_i_m1_p5, a_i_m1_p5, psi_a_m1_p5); + prodsum_psi_a_epi16(psi_r_m1_p3, a_r_m1_p3, psi_i_m1_p3, a_i_m1_p3, psi_a_m1_p3); + prodsum_psi_a_epi16(psi_r_m1_p1, a_r_m1_p1, psi_i_m1_p1, a_i_m1_p1, psi_a_m1_p1); + prodsum_psi_a_epi16(psi_r_m1_m1, a_r_m1_m1, psi_i_m1_m1, a_i_m1_m1, psi_a_m1_m1); + prodsum_psi_a_epi16(psi_r_m1_m3, a_r_m1_m3, psi_i_m1_m3, a_i_m1_m3, psi_a_m1_m3); + prodsum_psi_a_epi16(psi_r_m1_m5, a_r_m1_m5, psi_i_m1_m5, a_i_m1_m5, psi_a_m1_m5); + prodsum_psi_a_epi16(psi_r_m1_m7, a_r_m1_m7, psi_i_m1_m7, a_i_m1_m7, psi_a_m1_m7); + prodsum_psi_a_epi16(psi_r_m3_p7, a_r_m3_p7, psi_i_m3_p7, a_i_m3_p7, psi_a_m3_p7); + prodsum_psi_a_epi16(psi_r_m3_p5, a_r_m3_p5, psi_i_m3_p5, a_i_m3_p5, psi_a_m3_p5); + prodsum_psi_a_epi16(psi_r_m3_p3, a_r_m3_p3, psi_i_m3_p3, a_i_m3_p3, psi_a_m3_p3); + prodsum_psi_a_epi16(psi_r_m3_p1, a_r_m3_p1, psi_i_m3_p1, a_i_m3_p1, psi_a_m3_p1); + prodsum_psi_a_epi16(psi_r_m3_m1, a_r_m3_m1, psi_i_m3_m1, a_i_m3_m1, psi_a_m3_m1); + prodsum_psi_a_epi16(psi_r_m3_m3, a_r_m3_m3, psi_i_m3_m3, a_i_m3_m3, psi_a_m3_m3); + prodsum_psi_a_epi16(psi_r_m3_m5, a_r_m3_m5, psi_i_m3_m5, a_i_m3_m5, psi_a_m3_m5); + prodsum_psi_a_epi16(psi_r_m3_m7, a_r_m3_m7, psi_i_m3_m7, a_i_m3_m7, psi_a_m3_m7); + prodsum_psi_a_epi16(psi_r_m5_p7, a_r_m5_p7, psi_i_m5_p7, a_i_m5_p7, psi_a_m5_p7); + prodsum_psi_a_epi16(psi_r_m5_p5, a_r_m5_p5, psi_i_m5_p5, a_i_m5_p5, psi_a_m5_p5); + prodsum_psi_a_epi16(psi_r_m5_p3, a_r_m5_p3, psi_i_m5_p3, a_i_m5_p3, psi_a_m5_p3); + prodsum_psi_a_epi16(psi_r_m5_p1, a_r_m5_p1, psi_i_m5_p1, a_i_m5_p1, psi_a_m5_p1); + prodsum_psi_a_epi16(psi_r_m5_m1, a_r_m5_m1, psi_i_m5_m1, a_i_m5_m1, psi_a_m5_m1); + prodsum_psi_a_epi16(psi_r_m5_m3, a_r_m5_m3, psi_i_m5_m3, a_i_m5_m3, psi_a_m5_m3); + prodsum_psi_a_epi16(psi_r_m5_m5, a_r_m5_m5, psi_i_m5_m5, a_i_m5_m5, psi_a_m5_m5); + prodsum_psi_a_epi16(psi_r_m5_m7, a_r_m5_m7, psi_i_m5_m7, a_i_m5_m7, psi_a_m5_m7); + prodsum_psi_a_epi16(psi_r_m7_p7, a_r_m7_p7, psi_i_m7_p7, a_i_m7_p7, psi_a_m7_p7); + prodsum_psi_a_epi16(psi_r_m7_p5, a_r_m7_p5, psi_i_m7_p5, a_i_m7_p5, psi_a_m7_p5); + prodsum_psi_a_epi16(psi_r_m7_p3, a_r_m7_p3, psi_i_m7_p3, a_i_m7_p3, psi_a_m7_p3); + prodsum_psi_a_epi16(psi_r_m7_p1, a_r_m7_p1, psi_i_m7_p1, a_i_m7_p1, psi_a_m7_p1); + prodsum_psi_a_epi16(psi_r_m7_m1, a_r_m7_m1, psi_i_m7_m1, a_i_m7_m1, psi_a_m7_m1); + prodsum_psi_a_epi16(psi_r_m7_m3, a_r_m7_m3, psi_i_m7_m3, a_i_m7_m3, psi_a_m7_m3); + prodsum_psi_a_epi16(psi_r_m7_m5, a_r_m7_m5, psi_i_m7_m5, a_i_m7_m5, psi_a_m7_m5); + prodsum_psi_a_epi16(psi_r_m7_m7, a_r_m7_m7, psi_i_m7_m7, a_i_m7_m7, psi_a_m7_m7); + + // Multiply by sqrt(2) + psi_a_p7_p7 = simde_mm_mulhi_epi16(psi_a_p7_p7, ONE_OVER_SQRT_2); + psi_a_p7_p7 = simde_mm_slli_epi16(psi_a_p7_p7, 2); + psi_a_p7_p5 = simde_mm_mulhi_epi16(psi_a_p7_p5, ONE_OVER_SQRT_2); + psi_a_p7_p5 = simde_mm_slli_epi16(psi_a_p7_p5, 2); + psi_a_p7_p3 = simde_mm_mulhi_epi16(psi_a_p7_p3, ONE_OVER_SQRT_2); + psi_a_p7_p3 = simde_mm_slli_epi16(psi_a_p7_p3, 2); + psi_a_p7_p1 = simde_mm_mulhi_epi16(psi_a_p7_p1, ONE_OVER_SQRT_2); + psi_a_p7_p1 = simde_mm_slli_epi16(psi_a_p7_p1, 2); + psi_a_p7_m1 = simde_mm_mulhi_epi16(psi_a_p7_m1, ONE_OVER_SQRT_2); + psi_a_p7_m1 = simde_mm_slli_epi16(psi_a_p7_m1, 2); + psi_a_p7_m3 = simde_mm_mulhi_epi16(psi_a_p7_m3, ONE_OVER_SQRT_2); + psi_a_p7_m3 = simde_mm_slli_epi16(psi_a_p7_m3, 2); + psi_a_p7_m5 = simde_mm_mulhi_epi16(psi_a_p7_m5, ONE_OVER_SQRT_2); + psi_a_p7_m5 = simde_mm_slli_epi16(psi_a_p7_m5, 2); + psi_a_p7_m7 = simde_mm_mulhi_epi16(psi_a_p7_m7, ONE_OVER_SQRT_2); + psi_a_p7_m7 = simde_mm_slli_epi16(psi_a_p7_m7, 2); + psi_a_p5_p7 = simde_mm_mulhi_epi16(psi_a_p5_p7, ONE_OVER_SQRT_2); + psi_a_p5_p7 = simde_mm_slli_epi16(psi_a_p5_p7, 2); + psi_a_p5_p5 = simde_mm_mulhi_epi16(psi_a_p5_p5, ONE_OVER_SQRT_2); + psi_a_p5_p5 = simde_mm_slli_epi16(psi_a_p5_p5, 2); + psi_a_p5_p3 = simde_mm_mulhi_epi16(psi_a_p5_p3, ONE_OVER_SQRT_2); + psi_a_p5_p3 = simde_mm_slli_epi16(psi_a_p5_p3, 2); + psi_a_p5_p1 = simde_mm_mulhi_epi16(psi_a_p5_p1, ONE_OVER_SQRT_2); + psi_a_p5_p1 = simde_mm_slli_epi16(psi_a_p5_p1, 2); + psi_a_p5_m1 = simde_mm_mulhi_epi16(psi_a_p5_m1, ONE_OVER_SQRT_2); + psi_a_p5_m1 = simde_mm_slli_epi16(psi_a_p5_m1, 2); + psi_a_p5_m3 = simde_mm_mulhi_epi16(psi_a_p5_m3, ONE_OVER_SQRT_2); + psi_a_p5_m3 = simde_mm_slli_epi16(psi_a_p5_m3, 2); + psi_a_p5_m5 = simde_mm_mulhi_epi16(psi_a_p5_m5, ONE_OVER_SQRT_2); + psi_a_p5_m5 = simde_mm_slli_epi16(psi_a_p5_m5, 2); + psi_a_p5_m7 = simde_mm_mulhi_epi16(psi_a_p5_m7, ONE_OVER_SQRT_2); + psi_a_p5_m7 = simde_mm_slli_epi16(psi_a_p5_m7, 2); + psi_a_p3_p7 = simde_mm_mulhi_epi16(psi_a_p3_p7, ONE_OVER_SQRT_2); + psi_a_p3_p7 = simde_mm_slli_epi16(psi_a_p3_p7, 2); + psi_a_p3_p5 = simde_mm_mulhi_epi16(psi_a_p3_p5, ONE_OVER_SQRT_2); + psi_a_p3_p5 = simde_mm_slli_epi16(psi_a_p3_p5, 2); + psi_a_p3_p3 = simde_mm_mulhi_epi16(psi_a_p3_p3, ONE_OVER_SQRT_2); + psi_a_p3_p3 = simde_mm_slli_epi16(psi_a_p3_p3, 2); + psi_a_p3_p1 = simde_mm_mulhi_epi16(psi_a_p3_p1, ONE_OVER_SQRT_2); + psi_a_p3_p1 = simde_mm_slli_epi16(psi_a_p3_p1, 2); + psi_a_p3_m1 = simde_mm_mulhi_epi16(psi_a_p3_m1, ONE_OVER_SQRT_2); + psi_a_p3_m1 = simde_mm_slli_epi16(psi_a_p3_m1, 2); + psi_a_p3_m3 = simde_mm_mulhi_epi16(psi_a_p3_m3, ONE_OVER_SQRT_2); + psi_a_p3_m3 = simde_mm_slli_epi16(psi_a_p3_m3, 2); + psi_a_p3_m5 = simde_mm_mulhi_epi16(psi_a_p3_m5, ONE_OVER_SQRT_2); + psi_a_p3_m5 = simde_mm_slli_epi16(psi_a_p3_m5, 2); + psi_a_p3_m7 = simde_mm_mulhi_epi16(psi_a_p3_m7, ONE_OVER_SQRT_2); + psi_a_p3_m7 = simde_mm_slli_epi16(psi_a_p3_m7, 2); + psi_a_p1_p7 = simde_mm_mulhi_epi16(psi_a_p1_p7, ONE_OVER_SQRT_2); + psi_a_p1_p7 = simde_mm_slli_epi16(psi_a_p1_p7, 2); + psi_a_p1_p5 = simde_mm_mulhi_epi16(psi_a_p1_p5, ONE_OVER_SQRT_2); + psi_a_p1_p5 = simde_mm_slli_epi16(psi_a_p1_p5, 2); + psi_a_p1_p3 = simde_mm_mulhi_epi16(psi_a_p1_p3, ONE_OVER_SQRT_2); + psi_a_p1_p3 = simde_mm_slli_epi16(psi_a_p1_p3, 2); + psi_a_p1_p1 = simde_mm_mulhi_epi16(psi_a_p1_p1, ONE_OVER_SQRT_2); + psi_a_p1_p1 = simde_mm_slli_epi16(psi_a_p1_p1, 2); + psi_a_p1_m1 = simde_mm_mulhi_epi16(psi_a_p1_m1, ONE_OVER_SQRT_2); + psi_a_p1_m1 = simde_mm_slli_epi16(psi_a_p1_m1, 2); + psi_a_p1_m3 = simde_mm_mulhi_epi16(psi_a_p1_m3, ONE_OVER_SQRT_2); + psi_a_p1_m3 = simde_mm_slli_epi16(psi_a_p1_m3, 2); + psi_a_p1_m5 = simde_mm_mulhi_epi16(psi_a_p1_m5, ONE_OVER_SQRT_2); + psi_a_p1_m5 = simde_mm_slli_epi16(psi_a_p1_m5, 2); + psi_a_p1_m7 = simde_mm_mulhi_epi16(psi_a_p1_m7, ONE_OVER_SQRT_2); + psi_a_p1_m7 = simde_mm_slli_epi16(psi_a_p1_m7, 2); + psi_a_m1_p7 = simde_mm_mulhi_epi16(psi_a_m1_p7, ONE_OVER_SQRT_2); + psi_a_m1_p7 = simde_mm_slli_epi16(psi_a_m1_p7, 2); + psi_a_m1_p5 = simde_mm_mulhi_epi16(psi_a_m1_p5, ONE_OVER_SQRT_2); + psi_a_m1_p5 = simde_mm_slli_epi16(psi_a_m1_p5, 2); + psi_a_m1_p3 = simde_mm_mulhi_epi16(psi_a_m1_p3, ONE_OVER_SQRT_2); + psi_a_m1_p3 = simde_mm_slli_epi16(psi_a_m1_p3, 2); + psi_a_m1_p1 = simde_mm_mulhi_epi16(psi_a_m1_p1, ONE_OVER_SQRT_2); + psi_a_m1_p1 = simde_mm_slli_epi16(psi_a_m1_p1, 2); + psi_a_m1_m1 = simde_mm_mulhi_epi16(psi_a_m1_m1, ONE_OVER_SQRT_2); + psi_a_m1_m1 = simde_mm_slli_epi16(psi_a_m1_m1, 2); + psi_a_m1_m3 = simde_mm_mulhi_epi16(psi_a_m1_m3, ONE_OVER_SQRT_2); + psi_a_m1_m3 = simde_mm_slli_epi16(psi_a_m1_m3, 2); + psi_a_m1_m5 = simde_mm_mulhi_epi16(psi_a_m1_m5, ONE_OVER_SQRT_2); + psi_a_m1_m5 = simde_mm_slli_epi16(psi_a_m1_m5, 2); + psi_a_m1_m7 = simde_mm_mulhi_epi16(psi_a_m1_m7, ONE_OVER_SQRT_2); + psi_a_m1_m7 = simde_mm_slli_epi16(psi_a_m1_m7, 2); + psi_a_m3_p7 = simde_mm_mulhi_epi16(psi_a_m3_p7, ONE_OVER_SQRT_2); + psi_a_m3_p7 = simde_mm_slli_epi16(psi_a_m3_p7, 2); + psi_a_m3_p5 = simde_mm_mulhi_epi16(psi_a_m3_p5, ONE_OVER_SQRT_2); + psi_a_m3_p5 = simde_mm_slli_epi16(psi_a_m3_p5, 2); + psi_a_m3_p3 = simde_mm_mulhi_epi16(psi_a_m3_p3, ONE_OVER_SQRT_2); + psi_a_m3_p3 = simde_mm_slli_epi16(psi_a_m3_p3, 2); + psi_a_m3_p1 = simde_mm_mulhi_epi16(psi_a_m3_p1, ONE_OVER_SQRT_2); + psi_a_m3_p1 = simde_mm_slli_epi16(psi_a_m3_p1, 2); + psi_a_m3_m1 = simde_mm_mulhi_epi16(psi_a_m3_m1, ONE_OVER_SQRT_2); + psi_a_m3_m1 = simde_mm_slli_epi16(psi_a_m3_m1, 2); + psi_a_m3_m3 = simde_mm_mulhi_epi16(psi_a_m3_m3, ONE_OVER_SQRT_2); + psi_a_m3_m3 = simde_mm_slli_epi16(psi_a_m3_m3, 2); + psi_a_m3_m5 = simde_mm_mulhi_epi16(psi_a_m3_m5, ONE_OVER_SQRT_2); + psi_a_m3_m5 = simde_mm_slli_epi16(psi_a_m3_m5, 2); + psi_a_m3_m7 = simde_mm_mulhi_epi16(psi_a_m3_m7, ONE_OVER_SQRT_2); + psi_a_m3_m7 = simde_mm_slli_epi16(psi_a_m3_m7, 2); + psi_a_m5_p7 = simde_mm_mulhi_epi16(psi_a_m5_p7, ONE_OVER_SQRT_2); + psi_a_m5_p7 = simde_mm_slli_epi16(psi_a_m5_p7, 2); + psi_a_m5_p5 = simde_mm_mulhi_epi16(psi_a_m5_p5, ONE_OVER_SQRT_2); + psi_a_m5_p5 = simde_mm_slli_epi16(psi_a_m5_p5, 2); + psi_a_m5_p3 = simde_mm_mulhi_epi16(psi_a_m5_p3, ONE_OVER_SQRT_2); + psi_a_m5_p3 = simde_mm_slli_epi16(psi_a_m5_p3, 2); + psi_a_m5_p1 = simde_mm_mulhi_epi16(psi_a_m5_p1, ONE_OVER_SQRT_2); + psi_a_m5_p1 = simde_mm_slli_epi16(psi_a_m5_p1, 2); + psi_a_m5_m1 = simde_mm_mulhi_epi16(psi_a_m5_m1, ONE_OVER_SQRT_2); + psi_a_m5_m1 = simde_mm_slli_epi16(psi_a_m5_m1, 2); + psi_a_m5_m3 = simde_mm_mulhi_epi16(psi_a_m5_m3, ONE_OVER_SQRT_2); + psi_a_m5_m3 = simde_mm_slli_epi16(psi_a_m5_m3, 2); + psi_a_m5_m5 = simde_mm_mulhi_epi16(psi_a_m5_m5, ONE_OVER_SQRT_2); + psi_a_m5_m5 = simde_mm_slli_epi16(psi_a_m5_m5, 2); + psi_a_m5_m7 = simde_mm_mulhi_epi16(psi_a_m5_m7, ONE_OVER_SQRT_2); + psi_a_m5_m7 = simde_mm_slli_epi16(psi_a_m5_m7, 2); + psi_a_m7_p7 = simde_mm_mulhi_epi16(psi_a_m7_p7, ONE_OVER_SQRT_2); + psi_a_m7_p7 = simde_mm_slli_epi16(psi_a_m7_p7, 2); + psi_a_m7_p5 = simde_mm_mulhi_epi16(psi_a_m7_p5, ONE_OVER_SQRT_2); + psi_a_m7_p5 = simde_mm_slli_epi16(psi_a_m7_p5, 2); + psi_a_m7_p3 = simde_mm_mulhi_epi16(psi_a_m7_p3, ONE_OVER_SQRT_2); + psi_a_m7_p3 = simde_mm_slli_epi16(psi_a_m7_p3, 2); + psi_a_m7_p1 = simde_mm_mulhi_epi16(psi_a_m7_p1, ONE_OVER_SQRT_2); + psi_a_m7_p1 = simde_mm_slli_epi16(psi_a_m7_p1, 2); + psi_a_m7_m1 = simde_mm_mulhi_epi16(psi_a_m7_m1, ONE_OVER_SQRT_2); + psi_a_m7_m1 = simde_mm_slli_epi16(psi_a_m7_m1, 2); + psi_a_m7_m3 = simde_mm_mulhi_epi16(psi_a_m7_m3, ONE_OVER_SQRT_2); + psi_a_m7_m3 = simde_mm_slli_epi16(psi_a_m7_m3, 2); + psi_a_m7_m5 = simde_mm_mulhi_epi16(psi_a_m7_m5, ONE_OVER_SQRT_2); + psi_a_m7_m5 = simde_mm_slli_epi16(psi_a_m7_m5, 2); + psi_a_m7_m7 = simde_mm_mulhi_epi16(psi_a_m7_m7, ONE_OVER_SQRT_2); + psi_a_m7_m7 = simde_mm_slli_epi16(psi_a_m7_m7, 2); + + // Calculation of a group of two terms in the bit metric involving squares of interference + square_a_64qam_epi16(a_r_p7_p7, a_i_p7_p7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p7_p7); + square_a_64qam_epi16(a_r_p7_p5, a_i_p7_p5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p7_p5); + square_a_64qam_epi16(a_r_p7_p3, a_i_p7_p3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p7_p3); + square_a_64qam_epi16(a_r_p7_p1, a_i_p7_p1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p7_p1); + square_a_64qam_epi16(a_r_p7_m1, a_i_p7_m1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p7_m1); + square_a_64qam_epi16(a_r_p7_m3, a_i_p7_m3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p7_m3); + square_a_64qam_epi16(a_r_p7_m5, a_i_p7_m5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p7_m5); + square_a_64qam_epi16(a_r_p7_m7, a_i_p7_m7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p7_m7); + square_a_64qam_epi16(a_r_p5_p7, a_i_p5_p7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p5_p7); + square_a_64qam_epi16(a_r_p5_p5, a_i_p5_p5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p5_p5); + square_a_64qam_epi16(a_r_p5_p3, a_i_p5_p3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p5_p3); + square_a_64qam_epi16(a_r_p5_p1, a_i_p5_p1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p5_p1); + square_a_64qam_epi16(a_r_p5_m1, a_i_p5_m1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p5_m1); + square_a_64qam_epi16(a_r_p5_m3, a_i_p5_m3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p5_m3); + square_a_64qam_epi16(a_r_p5_m5, a_i_p5_m5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p5_m5); + square_a_64qam_epi16(a_r_p5_m7, a_i_p5_m7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p5_m7); + square_a_64qam_epi16(a_r_p3_p7, a_i_p3_p7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p3_p7); + square_a_64qam_epi16(a_r_p3_p5, a_i_p3_p5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p3_p5); + square_a_64qam_epi16(a_r_p3_p3, a_i_p3_p3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p3_p3); + square_a_64qam_epi16(a_r_p3_p1, a_i_p3_p1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p3_p1); + square_a_64qam_epi16(a_r_p3_m1, a_i_p3_m1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p3_m1); + square_a_64qam_epi16(a_r_p3_m3, a_i_p3_m3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p3_m3); + square_a_64qam_epi16(a_r_p3_m5, a_i_p3_m5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p3_m5); + square_a_64qam_epi16(a_r_p3_m7, a_i_p3_m7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p3_m7); + square_a_64qam_epi16(a_r_p1_p7, a_i_p1_p7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p1_p7); + square_a_64qam_epi16(a_r_p1_p5, a_i_p1_p5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p1_p5); + square_a_64qam_epi16(a_r_p1_p3, a_i_p1_p3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p1_p3); + square_a_64qam_epi16(a_r_p1_p1, a_i_p1_p1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p1_p1); + square_a_64qam_epi16(a_r_p1_m1, a_i_p1_m1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p1_m1); + square_a_64qam_epi16(a_r_p1_m3, a_i_p1_m3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p1_m3); + square_a_64qam_epi16(a_r_p1_m5, a_i_p1_m5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p1_m5); + square_a_64qam_epi16(a_r_p1_m7, a_i_p1_m7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p1_m7); + square_a_64qam_epi16(a_r_m1_p7, a_i_m1_p7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m1_p7); + square_a_64qam_epi16(a_r_m1_p5, a_i_m1_p5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m1_p5); + square_a_64qam_epi16(a_r_m1_p3, a_i_m1_p3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m1_p3); + square_a_64qam_epi16(a_r_m1_p1, a_i_m1_p1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m1_p1); + square_a_64qam_epi16(a_r_m1_m1, a_i_m1_m1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m1_m1); + square_a_64qam_epi16(a_r_m1_m3, a_i_m1_m3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m1_m3); + square_a_64qam_epi16(a_r_m1_m5, a_i_m1_m5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m1_m5); + square_a_64qam_epi16(a_r_m1_m7, a_i_m1_m7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m1_m7); + square_a_64qam_epi16(a_r_m3_p7, a_i_m3_p7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m3_p7); + square_a_64qam_epi16(a_r_m3_p5, a_i_m3_p5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m3_p5); + square_a_64qam_epi16(a_r_m3_p3, a_i_m3_p3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m3_p3); + square_a_64qam_epi16(a_r_m3_p1, a_i_m3_p1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m3_p1); + square_a_64qam_epi16(a_r_m3_m1, a_i_m3_m1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m3_m1); + square_a_64qam_epi16(a_r_m3_m3, a_i_m3_m3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m3_m3); + square_a_64qam_epi16(a_r_m3_m5, a_i_m3_m5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m3_m5); + square_a_64qam_epi16(a_r_m3_m7, a_i_m3_m7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m3_m7); + square_a_64qam_epi16(a_r_m5_p7, a_i_m5_p7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m5_p7); + square_a_64qam_epi16(a_r_m5_p5, a_i_m5_p5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m5_p5); + square_a_64qam_epi16(a_r_m5_p3, a_i_m5_p3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m5_p3); + square_a_64qam_epi16(a_r_m5_p1, a_i_m5_p1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m5_p1); + square_a_64qam_epi16(a_r_m5_m1, a_i_m5_m1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m5_m1); + square_a_64qam_epi16(a_r_m5_m3, a_i_m5_m3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m5_m3); + square_a_64qam_epi16(a_r_m5_m5, a_i_m5_m5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m5_m5); + square_a_64qam_epi16(a_r_m5_m7, a_i_m5_m7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m5_m7); + square_a_64qam_epi16(a_r_m7_p7, a_i_m7_p7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m7_p7); + square_a_64qam_epi16(a_r_m7_p5, a_i_m7_p5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m7_p5); + square_a_64qam_epi16(a_r_m7_p3, a_i_m7_p3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m7_p3); + square_a_64qam_epi16(a_r_m7_p1, a_i_m7_p1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m7_p1); + square_a_64qam_epi16(a_r_m7_m1, a_i_m7_m1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m7_m1); + square_a_64qam_epi16(a_r_m7_m3, a_i_m7_m3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m7_m3); + square_a_64qam_epi16(a_r_m7_m5, a_i_m7_m5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m7_m5); + square_a_64qam_epi16(a_r_m7_m7, a_i_m7_m7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m7_m7); + + // Computing different multiples of ||h0||^2 + // x=1, y=1 + ch_mag_2_over_42_with_sigma2 = simde_mm_mulhi_epi16(ch_mag_des, ONE_OVER_FOUR_SQRT_42); + ch_mag_2_over_42_with_sigma2 = simde_mm_slli_epi16(ch_mag_2_over_42_with_sigma2, 1); + // x=1, y=3 + ch_mag_10_over_42_with_sigma2 = simde_mm_mulhi_epi16(ch_mag_des, FIVE_OVER_FOUR_SQRT_42); + ch_mag_10_over_42_with_sigma2 = simde_mm_slli_epi16(ch_mag_10_over_42_with_sigma2, 1); + // x=1, x=5 + ch_mag_26_over_42_with_sigma2 = simde_mm_mulhi_epi16(ch_mag_des, THIRTEEN_OVER_FOUR_SQRT_42); + ch_mag_26_over_42_with_sigma2 = simde_mm_slli_epi16(ch_mag_26_over_42_with_sigma2, 1); + // x=1, y=7 + ch_mag_50_over_42_with_sigma2 = simde_mm_mulhi_epi16(ch_mag_des, TWENTYFIVE_OVER_FOUR_SQRT_42); + ch_mag_50_over_42_with_sigma2 = simde_mm_slli_epi16(ch_mag_50_over_42_with_sigma2, 1); + // x=3, y=3 + ch_mag_18_over_42_with_sigma2 = simde_mm_mulhi_epi16(ch_mag_des, NINE_OVER_FOUR_SQRT_42); + ch_mag_18_over_42_with_sigma2 = simde_mm_slli_epi16(ch_mag_18_over_42_with_sigma2, 1); + // x=3, y=5 + ch_mag_34_over_42_with_sigma2 = simde_mm_mulhi_epi16(ch_mag_des, SEVENTEEN_OVER_FOUR_SQRT_42); + ch_mag_34_over_42_with_sigma2 = simde_mm_slli_epi16(ch_mag_34_over_42_with_sigma2, 1); + // x=3, y=7 + ch_mag_58_over_42_with_sigma2 = simde_mm_mulhi_epi16(ch_mag_des, TWENTYNINE_OVER_FOUR_SQRT_42); + ch_mag_58_over_42_with_sigma2 = simde_mm_slli_epi16(ch_mag_58_over_42_with_sigma2, 2); + // x=5, y=5 + ch_mag_50_over_42_with_sigma2 = simde_mm_mulhi_epi16(ch_mag_des, TWENTYFIVE_OVER_FOUR_SQRT_42); + ch_mag_50_over_42_with_sigma2 = simde_mm_slli_epi16(ch_mag_50_over_42_with_sigma2, 1); + // x=5, y=7 + ch_mag_74_over_42_with_sigma2 = simde_mm_mulhi_epi16(ch_mag_des, THIRTYSEVEN_OVER_FOUR_SQRT_42); + ch_mag_74_over_42_with_sigma2 = simde_mm_slli_epi16(ch_mag_74_over_42_with_sigma2, 2); + // x=7, y=7 + ch_mag_98_over_42_with_sigma2 = simde_mm_mulhi_epi16(ch_mag_des, FORTYNINE_OVER_FOUR_SQRT_42); + ch_mag_98_over_42_with_sigma2 = simde_mm_slli_epi16(ch_mag_98_over_42_with_sigma2, 2); + + // Computing Metrics + xmm0 = simde_mm_subs_epi16(psi_a_p7_p7, a_sq_p7_p7); + simde__m128i xmm1 = simde_mm_adds_epi16(xmm0, y0_p_7_7); + simde__m128i bit_met_p7_p7 = simde_mm_subs_epi16(xmm1, ch_mag_98_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_p7_p5, a_sq_p7_p5); + xmm1 = simde_mm_adds_epi16(xmm0, y0_p_7_5); + simde__m128i bit_met_p7_p5 = simde_mm_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_p7_p3, a_sq_p7_p3); + xmm1 = simde_mm_adds_epi16(xmm0, y0_p_7_3); + simde__m128i bit_met_p7_p3 = simde_mm_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_p7_p1, a_sq_p7_p1); + xmm1 = simde_mm_adds_epi16(xmm0, y0_p_7_1); + simde__m128i bit_met_p7_p1 = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_p7_m1, a_sq_p7_m1); + xmm1 = simde_mm_adds_epi16(xmm0, y0_m_7_1); + simde__m128i bit_met_p7_m1 = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_p7_m3, a_sq_p7_m3); + xmm1 = simde_mm_adds_epi16(xmm0, y0_m_7_3); + simde__m128i bit_met_p7_m3 = simde_mm_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_p7_m5, a_sq_p7_m5); + xmm1 = simde_mm_adds_epi16(xmm0, y0_m_7_5); + simde__m128i bit_met_p7_m5 = simde_mm_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_p7_m7, a_sq_p7_m7); + xmm1 = simde_mm_adds_epi16(xmm0, y0_m_7_7); + simde__m128i bit_met_p7_m7 = simde_mm_subs_epi16(xmm1, ch_mag_98_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_p5_p7, a_sq_p5_p7); + xmm1 = simde_mm_adds_epi16(xmm0, y0_p_5_7); + simde__m128i bit_met_p5_p7 = simde_mm_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_p5_p5, a_sq_p5_p5); + xmm1 = simde_mm_adds_epi16(xmm0, y0_p_5_5); + simde__m128i bit_met_p5_p5 = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_p5_p3, a_sq_p5_p3); + xmm1 = simde_mm_adds_epi16(xmm0, y0_p_5_3); + simde__m128i bit_met_p5_p3 = simde_mm_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_p5_p1, a_sq_p5_p1); + xmm1 = simde_mm_adds_epi16(xmm0, y0_p_5_1); + simde__m128i bit_met_p5_p1 = simde_mm_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_p5_m1, a_sq_p5_m1); + xmm1 = simde_mm_adds_epi16(xmm0, y0_m_5_1); + simde__m128i bit_met_p5_m1 = simde_mm_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_p5_m3, a_sq_p5_m3); + xmm1 = simde_mm_adds_epi16(xmm0, y0_m_5_3); + simde__m128i bit_met_p5_m3 = simde_mm_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_p5_m5, a_sq_p5_m5); + xmm1 = simde_mm_adds_epi16(xmm0, y0_m_5_5); + simde__m128i bit_met_p5_m5 = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_p5_m7, a_sq_p5_m7); + xmm1 = simde_mm_adds_epi16(xmm0, y0_m_5_7); + simde__m128i bit_met_p5_m7 = simde_mm_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_p3_p7, a_sq_p3_p7); + xmm1 = simde_mm_adds_epi16(xmm0, y0_p_3_7); + simde__m128i bit_met_p3_p7 = simde_mm_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_p3_p5, a_sq_p3_p5); + xmm1 = simde_mm_adds_epi16(xmm0, y0_p_3_5); + simde__m128i bit_met_p3_p5 = simde_mm_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_p3_p3, a_sq_p3_p3); + xmm1 = simde_mm_adds_epi16(xmm0, y0_p_3_3); + simde__m128i bit_met_p3_p3 = simde_mm_subs_epi16(xmm1, ch_mag_18_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_p3_p1, a_sq_p3_p1); + xmm1 = simde_mm_adds_epi16(xmm0, y0_p_3_1); + simde__m128i bit_met_p3_p1 = simde_mm_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_p3_m1, a_sq_p3_m1); + xmm1 = simde_mm_adds_epi16(xmm0, y0_m_3_1); + simde__m128i bit_met_p3_m1 = simde_mm_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_p3_m3, a_sq_p3_m3); + xmm1 = simde_mm_adds_epi16(xmm0, y0_m_3_3); + simde__m128i bit_met_p3_m3 = simde_mm_subs_epi16(xmm1, ch_mag_18_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_p3_m5, a_sq_p3_m5); + xmm1 = simde_mm_adds_epi16(xmm0, y0_m_3_5); + simde__m128i bit_met_p3_m5 = simde_mm_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_p3_m7, a_sq_p3_m7); + xmm1 = simde_mm_adds_epi16(xmm0, y0_m_3_7); + simde__m128i bit_met_p3_m7 = simde_mm_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_p1_p7, a_sq_p1_p7); + xmm1 = simde_mm_adds_epi16(xmm0, y0_p_1_7); + simde__m128i bit_met_p1_p7 = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_p1_p5, a_sq_p1_p5); + xmm1 = simde_mm_adds_epi16(xmm0, y0_p_1_5); + simde__m128i bit_met_p1_p5 = simde_mm_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_p1_p3, a_sq_p1_p3); + xmm1 = simde_mm_adds_epi16(xmm0, y0_p_1_3); + simde__m128i bit_met_p1_p3 = simde_mm_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_p1_p1, a_sq_p1_p1); + xmm1 = simde_mm_adds_epi16(xmm0, y0_p_1_1); + simde__m128i bit_met_p1_p1 = simde_mm_subs_epi16(xmm1, ch_mag_2_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_p1_m1, a_sq_p1_m1); + xmm1 = simde_mm_adds_epi16(xmm0, y0_m_1_1); + simde__m128i bit_met_p1_m1 = simde_mm_subs_epi16(xmm1, ch_mag_2_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_p1_m3, a_sq_p1_m3); + xmm1 = simde_mm_adds_epi16(xmm0, y0_m_1_3); + simde__m128i bit_met_p1_m3 = simde_mm_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_p1_m5, a_sq_p1_m5); + xmm1 = simde_mm_adds_epi16(xmm0, y0_m_1_5); + simde__m128i bit_met_p1_m5 = simde_mm_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_p1_m7, a_sq_p1_m7); + xmm1 = simde_mm_adds_epi16(xmm0, y0_m_1_7); + simde__m128i bit_met_p1_m7 = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + + xmm0 = simde_mm_subs_epi16(psi_a_m1_p7, a_sq_m1_p7); + xmm1 = simde_mm_subs_epi16(xmm0, y0_m_1_7); + simde__m128i bit_met_m1_p7 = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_m1_p5, a_sq_m1_p5); + xmm1 = simde_mm_subs_epi16(xmm0, y0_m_1_5); + simde__m128i bit_met_m1_p5 = simde_mm_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_m1_p3, a_sq_m1_p3); + xmm1 = simde_mm_subs_epi16(xmm0, y0_m_1_3); + simde__m128i bit_met_m1_p3 = simde_mm_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_m1_p1, a_sq_m1_p1); + xmm1 = simde_mm_subs_epi16(xmm0, y0_m_1_1); + simde__m128i bit_met_m1_p1 = simde_mm_subs_epi16(xmm1, ch_mag_2_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_m1_m1, a_sq_m1_m1); + xmm1 = simde_mm_subs_epi16(xmm0, y0_p_1_1); + simde__m128i bit_met_m1_m1 = simde_mm_subs_epi16(xmm1, ch_mag_2_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_m1_m3, a_sq_m1_m3); + xmm1 = simde_mm_subs_epi16(xmm0, y0_p_1_3); + simde__m128i bit_met_m1_m3 = simde_mm_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_m1_m5, a_sq_m1_m5); + xmm1 = simde_mm_subs_epi16(xmm0, y0_p_1_5); + simde__m128i bit_met_m1_m5 = simde_mm_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_m1_m7, a_sq_m1_m7); + xmm1 = simde_mm_subs_epi16(xmm0, y0_p_1_7); + simde__m128i bit_met_m1_m7 = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_m3_p7, a_sq_m3_p7); + xmm1 = simde_mm_subs_epi16(xmm0, y0_m_3_7); + simde__m128i bit_met_m3_p7 = simde_mm_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_m3_p5, a_sq_m3_p5); + xmm1 = simde_mm_subs_epi16(xmm0, y0_m_3_5); + simde__m128i bit_met_m3_p5 = simde_mm_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_m3_p3, a_sq_m3_p3); + xmm1 = simde_mm_subs_epi16(xmm0, y0_m_3_3); + simde__m128i bit_met_m3_p3 = simde_mm_subs_epi16(xmm1, ch_mag_18_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_m3_p1, a_sq_m3_p1); + xmm1 = simde_mm_subs_epi16(xmm0, y0_m_3_1); + simde__m128i bit_met_m3_p1 = simde_mm_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_m3_m1, a_sq_m3_m1); + xmm1 = simde_mm_subs_epi16(xmm0, y0_p_3_1); + simde__m128i bit_met_m3_m1 = simde_mm_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_m3_m3, a_sq_m3_m3); + xmm1 = simde_mm_subs_epi16(xmm0, y0_p_3_3); + simde__m128i bit_met_m3_m3 = simde_mm_subs_epi16(xmm1, ch_mag_18_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_m3_m5, a_sq_m3_m5); + xmm1 = simde_mm_subs_epi16(xmm0, y0_p_3_5); + simde__m128i bit_met_m3_m5 = simde_mm_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_m3_m7, a_sq_m3_m7); + xmm1 = simde_mm_subs_epi16(xmm0, y0_p_3_7); + simde__m128i bit_met_m3_m7 = simde_mm_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_m5_p7, a_sq_m5_p7); + xmm1 = simde_mm_subs_epi16(xmm0, y0_m_5_7); + simde__m128i bit_met_m5_p7 = simde_mm_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_m5_p5, a_sq_m5_p5); + xmm1 = simde_mm_subs_epi16(xmm0, y0_m_5_5); + simde__m128i bit_met_m5_p5 = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_m5_p3, a_sq_m5_p3); + xmm1 = simde_mm_subs_epi16(xmm0, y0_m_5_3); + simde__m128i bit_met_m5_p3 = simde_mm_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_m5_p1, a_sq_m5_p1); + xmm1 = simde_mm_subs_epi16(xmm0, y0_m_5_1); + simde__m128i bit_met_m5_p1 = simde_mm_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_m5_m1, a_sq_m5_m1); + xmm1 = simde_mm_subs_epi16(xmm0, y0_p_5_1); + simde__m128i bit_met_m5_m1 = simde_mm_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_m5_m3, a_sq_m5_m3); + xmm1 = simde_mm_subs_epi16(xmm0, y0_p_5_3); + simde__m128i bit_met_m5_m3 = simde_mm_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_m5_m5, a_sq_m5_m5); + xmm1 = simde_mm_subs_epi16(xmm0, y0_p_5_5); + simde__m128i bit_met_m5_m5 = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_m5_m7, a_sq_m5_m7); + xmm1 = simde_mm_subs_epi16(xmm0, y0_p_5_7); + simde__m128i bit_met_m5_m7 = simde_mm_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_m7_p7, a_sq_m7_p7); + xmm1 = simde_mm_subs_epi16(xmm0, y0_m_7_7); + simde__m128i bit_met_m7_p7 = simde_mm_subs_epi16(xmm1, ch_mag_98_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_m7_p5, a_sq_m7_p5); + xmm1 = simde_mm_subs_epi16(xmm0, y0_m_7_5); + simde__m128i bit_met_m7_p5 = simde_mm_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_m7_p3, a_sq_m7_p3); + xmm1 = simde_mm_subs_epi16(xmm0, y0_m_7_3); + simde__m128i bit_met_m7_p3 = simde_mm_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_m7_p1, a_sq_m7_p1); + xmm1 = simde_mm_subs_epi16(xmm0, y0_m_7_1); + simde__m128i bit_met_m7_p1 = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_m7_m1, a_sq_m7_m1); + xmm1 = simde_mm_subs_epi16(xmm0, y0_p_7_1); + simde__m128i bit_met_m7_m1 = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_m7_m3, a_sq_m7_m3); + xmm1 = simde_mm_subs_epi16(xmm0, y0_p_7_3); + simde__m128i bit_met_m7_m3 = simde_mm_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_m7_m5, a_sq_m7_m5); + xmm1 = simde_mm_subs_epi16(xmm0, y0_p_7_5); + simde__m128i bit_met_m7_m5 = simde_mm_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); + xmm0 = simde_mm_subs_epi16(psi_a_m7_m7, a_sq_m7_m7); + xmm1 = simde_mm_subs_epi16(xmm0, y0_p_7_7); + simde__m128i bit_met_m7_m7 = simde_mm_subs_epi16(xmm1, ch_mag_98_over_42_with_sigma2); + + // Detection for 1st bit + // bit = 1 + xmm0 = simde_mm_max_epi16(bit_met_m7_p7, bit_met_m7_p5); + xmm1 = simde_mm_max_epi16(bit_met_m7_p3, bit_met_m7_p1); + xmm2 = simde_mm_max_epi16(bit_met_m7_m1, bit_met_m7_m3); + xmm3 = simde_mm_max_epi16(bit_met_m7_m5, bit_met_m7_m7); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + simde__m128i logmax_den_re0 = simde_mm_max_epi16(xmm4, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_m5_p7, bit_met_m5_p5); + xmm1 = simde_mm_max_epi16(bit_met_m5_p3, bit_met_m5_p1); + xmm2 = simde_mm_max_epi16(bit_met_m5_m1, bit_met_m5_m3); + xmm3 = simde_mm_max_epi16(bit_met_m5_m5, bit_met_m5_m7); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_m3_p7, bit_met_m3_p5); + xmm1 = simde_mm_max_epi16(bit_met_m3_p3, bit_met_m3_p1); + xmm2 = simde_mm_max_epi16(bit_met_m3_m1, bit_met_m3_m3); + xmm3 = simde_mm_max_epi16(bit_met_m3_m5, bit_met_m3_m7); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_m1_p7, bit_met_m1_p5); + xmm1 = simde_mm_max_epi16(bit_met_m1_p3, bit_met_m1_p1); + xmm2 = simde_mm_max_epi16(bit_met_m1_m1, bit_met_m1_m3); + xmm3 = simde_mm_max_epi16(bit_met_m1_m5, bit_met_m1_m7); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); + + // bit = 0 + xmm0 = simde_mm_max_epi16(bit_met_p7_p7, bit_met_p7_p5); + xmm1 = simde_mm_max_epi16(bit_met_p7_p3, bit_met_p7_p1); + xmm2 = simde_mm_max_epi16(bit_met_p7_m1, bit_met_p7_m3); + xmm3 = simde_mm_max_epi16(bit_met_p7_m5, bit_met_p7_m7); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + simde__m128i logmax_num_re0 = simde_mm_max_epi16(xmm4, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_p5_p7, bit_met_p5_p5); + xmm1 = simde_mm_max_epi16(bit_met_p5_p3, bit_met_p5_p1); + xmm2 = simde_mm_max_epi16(bit_met_p5_m1, bit_met_p5_m3); + xmm3 = simde_mm_max_epi16(bit_met_p5_m5, bit_met_p5_m7); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_p3_p7, bit_met_p3_p5); + xmm1 = simde_mm_max_epi16(bit_met_p3_p3, bit_met_p3_p1); + xmm2 = simde_mm_max_epi16(bit_met_p3_m1, bit_met_p3_m3); + xmm3 = simde_mm_max_epi16(bit_met_p3_m5, bit_met_p3_m7); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_p1_p7, bit_met_p1_p5); + xmm1 = simde_mm_max_epi16(bit_met_p1_p3, bit_met_p1_p1); + xmm2 = simde_mm_max_epi16(bit_met_p1_m1, bit_met_p1_m3); + xmm3 = simde_mm_max_epi16(bit_met_p1_m5, bit_met_p1_m7); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); + + y0r = simde_mm_subs_epi16(logmax_num_re0, logmax_den_re0); + + // Detection for 2nd bit + // bit = 1 + xmm0 = simde_mm_max_epi16(bit_met_p7_m1, bit_met_p5_m1); + xmm1 = simde_mm_max_epi16(bit_met_p3_m1, bit_met_p1_m1); + xmm2 = simde_mm_max_epi16(bit_met_m1_m1, bit_met_m3_m1); + xmm3 = simde_mm_max_epi16(bit_met_m5_m1, bit_met_m7_m1); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_den_re0 = simde_mm_max_epi16(xmm4, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_p7_m3, bit_met_p5_m3); + xmm1 = simde_mm_max_epi16(bit_met_p3_m3, bit_met_p1_m3); + xmm2 = simde_mm_max_epi16(bit_met_m1_m3, bit_met_m3_m3); + xmm3 = simde_mm_max_epi16(bit_met_m5_m3, bit_met_m7_m3); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_p7_m5, bit_met_p5_m5); + xmm1 = simde_mm_max_epi16(bit_met_p3_m5, bit_met_p1_m5); + xmm2 = simde_mm_max_epi16(bit_met_m1_m5, bit_met_m3_m5); + xmm3 = simde_mm_max_epi16(bit_met_m5_m5, bit_met_m7_m5); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_p7_m7, bit_met_p5_m7); + xmm1 = simde_mm_max_epi16(bit_met_p3_m7, bit_met_p1_m7); + xmm2 = simde_mm_max_epi16(bit_met_m1_m7, bit_met_m3_m7); + xmm3 = simde_mm_max_epi16(bit_met_m5_m7, bit_met_m7_m7); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); + + // bit = 0 + xmm0 = simde_mm_max_epi16(bit_met_p7_p1, bit_met_p5_p1); + xmm1 = simde_mm_max_epi16(bit_met_p3_p1, bit_met_p1_p1); + xmm2 = simde_mm_max_epi16(bit_met_m1_p1, bit_met_m3_p1); + xmm3 = simde_mm_max_epi16(bit_met_m5_p1, bit_met_m7_p1); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_num_re0 = simde_mm_max_epi16(xmm4, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_p7_p3, bit_met_p5_p3); + xmm1 = simde_mm_max_epi16(bit_met_p3_p3, bit_met_p1_p3); + xmm2 = simde_mm_max_epi16(bit_met_m1_p3, bit_met_m3_p3); + xmm3 = simde_mm_max_epi16(bit_met_m5_p3, bit_met_m7_p3); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_p7_p5, bit_met_p5_p5); + xmm1 = simde_mm_max_epi16(bit_met_p3_p5, bit_met_p1_p5); + xmm2 = simde_mm_max_epi16(bit_met_m1_p5, bit_met_m3_p5); + xmm3 = simde_mm_max_epi16(bit_met_m5_p5, bit_met_m7_p5); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_p7_p7, bit_met_p5_p7); + xmm1 = simde_mm_max_epi16(bit_met_p3_p7, bit_met_p1_p7); + xmm2 = simde_mm_max_epi16(bit_met_m1_p7, bit_met_m3_p7); + xmm3 = simde_mm_max_epi16(bit_met_m5_p7, bit_met_m7_p7); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); + + y1r = simde_mm_subs_epi16(logmax_num_re0, logmax_den_re0); + + // Detection for 3rd bit + xmm0 = simde_mm_max_epi16(bit_met_m7_m7, bit_met_m7_m5); + xmm1 = simde_mm_max_epi16(bit_met_m7_m3, bit_met_m7_m1); + xmm2 = simde_mm_max_epi16(bit_met_m7_p1, bit_met_m7_p3); + xmm3 = simde_mm_max_epi16(bit_met_m7_p5, bit_met_m7_p7); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_den_re0 = simde_mm_max_epi16(xmm4, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_m5_m7, bit_met_m5_m5); + xmm1 = simde_mm_max_epi16(bit_met_m5_m3, bit_met_m5_m1); + xmm2 = simde_mm_max_epi16(bit_met_m5_p1, bit_met_m5_p3); + xmm3 = simde_mm_max_epi16(bit_met_m5_p5, bit_met_m5_p7); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_p5_m7, bit_met_p5_m5); + xmm1 = simde_mm_max_epi16(bit_met_p5_m3, bit_met_p5_m1); + xmm2 = simde_mm_max_epi16(bit_met_p5_p1, bit_met_p5_p3); + xmm3 = simde_mm_max_epi16(bit_met_p5_p5, bit_met_p5_p7); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_p7_m7, bit_met_p7_m5); + xmm1 = simde_mm_max_epi16(bit_met_p7_m3, bit_met_p7_m1); + xmm2 = simde_mm_max_epi16(bit_met_p7_p1, bit_met_p7_p3); + xmm3 = simde_mm_max_epi16(bit_met_p7_p5, bit_met_p7_p7); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); + + xmm0 = simde_mm_max_epi16(bit_met_m3_m7, bit_met_m3_m5); + xmm1 = simde_mm_max_epi16(bit_met_m3_m3, bit_met_m3_m1); + xmm2 = simde_mm_max_epi16(bit_met_m3_p1, bit_met_m3_p3); + xmm3 = simde_mm_max_epi16(bit_met_m3_p5, bit_met_m3_p7); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_num_re0 = simde_mm_max_epi16(xmm4, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_m1_m7, bit_met_m1_m5); + xmm1 = simde_mm_max_epi16(bit_met_m1_m3, bit_met_m1_m1); + xmm2 = simde_mm_max_epi16(bit_met_m1_p1, bit_met_m1_p3); + xmm3 = simde_mm_max_epi16(bit_met_m1_p5, bit_met_m1_p7); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_p1_m7, bit_met_p1_m5); + xmm1 = simde_mm_max_epi16(bit_met_p1_m3, bit_met_p1_m1); + xmm2 = simde_mm_max_epi16(bit_met_p1_p1, bit_met_p1_p3); + xmm3 = simde_mm_max_epi16(bit_met_p1_p5, bit_met_p1_p7); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_p3_m7, bit_met_p3_m5); + xmm1 = simde_mm_max_epi16(bit_met_p3_m3, bit_met_p3_m1); + xmm2 = simde_mm_max_epi16(bit_met_p3_p1, bit_met_p3_p3); + xmm3 = simde_mm_max_epi16(bit_met_p3_p5, bit_met_p3_p7); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); + + simde__m128i y2r = simde_mm_subs_epi16(logmax_num_re0, logmax_den_re0); + + // Detection for 4th bit + xmm0 = simde_mm_max_epi16(bit_met_p7_p7, bit_met_p5_p7); + xmm1 = simde_mm_max_epi16(bit_met_p3_p7, bit_met_p1_p7); + xmm2 = simde_mm_max_epi16(bit_met_m1_p7, bit_met_m3_p7); + xmm3 = simde_mm_max_epi16(bit_met_m5_p7, bit_met_m7_p7); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_den_re0 = simde_mm_max_epi16(xmm4, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_p7_p5, bit_met_p5_p5); + xmm1 = simde_mm_max_epi16(bit_met_p3_p5, bit_met_p1_p5); + xmm2 = simde_mm_max_epi16(bit_met_m1_p5, bit_met_m3_p5); + xmm3 = simde_mm_max_epi16(bit_met_m5_p5, bit_met_m5_p5); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_p7_m5, bit_met_p5_m5); + xmm1 = simde_mm_max_epi16(bit_met_p3_m5, bit_met_p1_m5); + xmm2 = simde_mm_max_epi16(bit_met_m1_m5, bit_met_m3_m5); + xmm3 = simde_mm_max_epi16(bit_met_m5_m5, bit_met_m7_m5); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_p7_m7, bit_met_p5_m7); + xmm1 = simde_mm_max_epi16(bit_met_p3_m7, bit_met_p1_m7); + xmm2 = simde_mm_max_epi16(bit_met_m1_m7, bit_met_m3_m7); + xmm3 = simde_mm_max_epi16(bit_met_m5_m7, bit_met_m7_m7); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); + + xmm0 = simde_mm_max_epi16(bit_met_p7_m1, bit_met_p5_m1); + xmm1 = simde_mm_max_epi16(bit_met_p3_m1, bit_met_p1_m1); + xmm2 = simde_mm_max_epi16(bit_met_m1_m1, bit_met_m3_m1); + xmm3 = simde_mm_max_epi16(bit_met_m5_m1, bit_met_m7_m1); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_num_re0 = simde_mm_max_epi16(xmm4, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_p7_m3, bit_met_p5_m3); + xmm1 = simde_mm_max_epi16(bit_met_p3_m3, bit_met_p1_m3); + xmm2 = simde_mm_max_epi16(bit_met_m1_m3, bit_met_m3_m3); + xmm3 = simde_mm_max_epi16(bit_met_m5_m3, bit_met_m7_m3); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_p7_p1, bit_met_p5_p1); + xmm1 = simde_mm_max_epi16(bit_met_p3_p1, bit_met_p1_p1); + xmm2 = simde_mm_max_epi16(bit_met_m1_p1, bit_met_m3_p1); + xmm3 = simde_mm_max_epi16(bit_met_m5_p1, bit_met_m7_p1); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_p7_p3, bit_met_p5_p3); + xmm1 = simde_mm_max_epi16(bit_met_p3_p3, bit_met_p1_p3); + xmm2 = simde_mm_max_epi16(bit_met_m1_p3, bit_met_m3_p3); + xmm3 = simde_mm_max_epi16(bit_met_m5_p3, bit_met_m7_p3); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); + + y0i = simde_mm_subs_epi16(logmax_num_re0, logmax_den_re0); + + // Detection for 5th bit + xmm0 = simde_mm_max_epi16(bit_met_m7_m7, bit_met_m7_m5); + xmm1 = simde_mm_max_epi16(bit_met_m7_m3, bit_met_m7_m1); + xmm2 = simde_mm_max_epi16(bit_met_m7_p1, bit_met_m7_p3); + xmm3 = simde_mm_max_epi16(bit_met_m7_p5, bit_met_m7_p7); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_den_re0 = simde_mm_max_epi16(xmm4, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_m1_m7, bit_met_m1_m5); + xmm1 = simde_mm_max_epi16(bit_met_m1_m3, bit_met_m1_m1); + xmm2 = simde_mm_max_epi16(bit_met_m1_p1, bit_met_m1_p3); + xmm3 = simde_mm_max_epi16(bit_met_m1_p5, bit_met_m1_p7); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_p1_m7, bit_met_p1_m5); + xmm1 = simde_mm_max_epi16(bit_met_p1_m3, bit_met_p1_m1); + xmm2 = simde_mm_max_epi16(bit_met_p1_p1, bit_met_p1_p3); + xmm3 = simde_mm_max_epi16(bit_met_p1_p5, bit_met_p1_p7); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_p7_m7, bit_met_p7_m5); + xmm1 = simde_mm_max_epi16(bit_met_p7_m3, bit_met_p7_m1); + xmm2 = simde_mm_max_epi16(bit_met_p7_p1, bit_met_p7_p3); + xmm3 = simde_mm_max_epi16(bit_met_p7_p5, bit_met_p7_p7); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); + + xmm0 = simde_mm_max_epi16(bit_met_m5_m7, bit_met_m5_m5); + xmm1 = simde_mm_max_epi16(bit_met_m5_m3, bit_met_m5_m1); + xmm2 = simde_mm_max_epi16(bit_met_m5_p1, bit_met_m5_p3); + xmm3 = simde_mm_max_epi16(bit_met_m5_p5, bit_met_m5_p7); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_num_re0 = simde_mm_max_epi16(xmm4, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_m3_m7, bit_met_m3_m5); + xmm1 = simde_mm_max_epi16(bit_met_m3_m3, bit_met_m3_m1); + xmm2 = simde_mm_max_epi16(bit_met_m3_p1, bit_met_m3_p3); + xmm3 = simde_mm_max_epi16(bit_met_m3_p5, bit_met_m3_p7); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_p3_m7, bit_met_p3_m5); + xmm1 = simde_mm_max_epi16(bit_met_p3_m3, bit_met_p3_m1); + xmm2 = simde_mm_max_epi16(bit_met_p3_p1, bit_met_p3_p3); + xmm3 = simde_mm_max_epi16(bit_met_p3_p5, bit_met_p3_p7); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_p5_m7, bit_met_p5_m5); + xmm1 = simde_mm_max_epi16(bit_met_p5_m3, bit_met_p5_m1); + xmm2 = simde_mm_max_epi16(bit_met_p5_p1, bit_met_p5_p3); + xmm3 = simde_mm_max_epi16(bit_met_p5_p5, bit_met_p5_p7); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); + + y1i = simde_mm_subs_epi16(logmax_num_re0, logmax_den_re0); + + // Detection for 6th bit + xmm0 = simde_mm_max_epi16(bit_met_p7_p7, bit_met_p5_p7); + xmm1 = simde_mm_max_epi16(bit_met_p3_p7, bit_met_p1_p7); + xmm2 = simde_mm_max_epi16(bit_met_m1_p7, bit_met_m3_p7); + xmm3 = simde_mm_max_epi16(bit_met_m5_p7, bit_met_m7_p7); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_den_re0 = simde_mm_max_epi16(xmm4, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_p7_p1, bit_met_p5_p1); + xmm1 = simde_mm_max_epi16(bit_met_p3_p1, bit_met_p1_p1); + xmm2 = simde_mm_max_epi16(bit_met_m1_p1, bit_met_m3_p1); + xmm3 = simde_mm_max_epi16(bit_met_m5_p1, bit_met_m5_p1); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_p7_m1, bit_met_p5_m1); + xmm1 = simde_mm_max_epi16(bit_met_p3_m1, bit_met_p1_m1); + xmm2 = simde_mm_max_epi16(bit_met_m1_m1, bit_met_m3_m1); + xmm3 = simde_mm_max_epi16(bit_met_m5_m1, bit_met_m7_m1); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_p7_m7, bit_met_p5_m7); + xmm1 = simde_mm_max_epi16(bit_met_p3_m7, bit_met_p1_m7); + xmm2 = simde_mm_max_epi16(bit_met_m1_m7, bit_met_m3_m7); + xmm3 = simde_mm_max_epi16(bit_met_m5_m7, bit_met_m7_m7); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); + logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); + + xmm0 = simde_mm_max_epi16(bit_met_p7_m5, bit_met_p5_m5); + xmm1 = simde_mm_max_epi16(bit_met_p3_m5, bit_met_p1_m5); + xmm2 = simde_mm_max_epi16(bit_met_m1_m5, bit_met_m3_m5); + xmm3 = simde_mm_max_epi16(bit_met_m5_m5, bit_met_m7_m5); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_num_re0 = simde_mm_max_epi16(xmm4, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_p7_m3, bit_met_p5_m3); + xmm1 = simde_mm_max_epi16(bit_met_p3_m3, bit_met_p1_m3); + xmm2 = simde_mm_max_epi16(bit_met_m1_m3, bit_met_m3_m3); + xmm3 = simde_mm_max_epi16(bit_met_m5_m3, bit_met_m7_m3); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_p7_p3, bit_met_p5_p3); + xmm1 = simde_mm_max_epi16(bit_met_p3_p3, bit_met_p1_p3); + xmm2 = simde_mm_max_epi16(bit_met_m1_p3, bit_met_m3_p3); + xmm3 = simde_mm_max_epi16(bit_met_m5_p3, bit_met_m7_p3); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); + xmm0 = simde_mm_max_epi16(bit_met_p7_p5, bit_met_p5_p5); + xmm1 = simde_mm_max_epi16(bit_met_p3_p5, bit_met_p1_p5); + xmm2 = simde_mm_max_epi16(bit_met_m1_p5, bit_met_m3_p5); + xmm3 = simde_mm_max_epi16(bit_met_m5_p5, bit_met_m7_p5); + xmm4 = simde_mm_max_epi16(xmm0, xmm1); + xmm5 = simde_mm_max_epi16(xmm2, xmm3); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); + logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); + + simde__m128i y2i = simde_mm_subs_epi16(logmax_num_re0, logmax_den_re0); + + // Map to output stream, difficult to do in SIMD since we have 6 16bit LLRs + int idx0 = 12 * i; + for (int re = 0; re < 8; re++) { + stream0_out[idx0 + 0].r = ((short *)&y0r)[re]; + stream0_out[idx0 + 0].i = ((short *)&y1r)[re]; + stream0_out[idx0 + 1].r = ((short *)&y2r)[re]; + stream0_out[idx0 + 1].i = ((short *)&y0i)[re]; + stream0_out[idx0 + 2].r = ((short *)&y1i)[re]; + stream0_out[idx0 + 2].i = ((short *)&y2i)[re]; + idx0 += 3; + } + } +#else simde__m256i *rho01_256i = (simde__m256i *)rho01; simde__m256i *stream0_256i_in = (simde__m256i *)stream0_in; simde__m256i *stream1_256i_in = (simde__m256i *)stream1_in; @@ -3612,6 +6905,7 @@ void nr_ulsch_qam64_qam64(c16_t *stream0_in, idx0 += 3; } } +#endif simde_mm_empty(); simde_m_empty(); @@ -3640,35 +6934,3 @@ static void nr_ulsch_shift_llr(int16_t **llr_layers, uint32_t nb_re, uint32_t rx llr_layers1[i] = simde_mm_srai_epi16(llr_layers1[i], shift); } } - -void nr_ulsch_compute_ML_llr(NR_gNB_PUSCH *pusch_vars, - uint32_t symbol, - c16_t* rxdataF_comp0, - c16_t* rxdataF_comp1, - c16_t* ul_ch_mag0, - c16_t* ul_ch_mag1, - c16_t* llr_layers0, - c16_t* llr_layers1, - c16_t* rho0, - c16_t* rho1, - uint32_t nb_re, - uint8_t mod_order) -{ - switch (mod_order) { - case 2: - nr_ulsch_qpsk_qpsk(rxdataF_comp0, rxdataF_comp1, llr_layers0, rho0, nb_re); - nr_ulsch_qpsk_qpsk(rxdataF_comp1, rxdataF_comp0, llr_layers1, rho1, nb_re); - nr_ulsch_shift_llr(pusch_vars->llr_layers, nb_re, pusch_vars->llr_offset[symbol] >> 1, 2, 4); - break; - case 4: - nr_ulsch_qam16_qam16(rxdataF_comp0, rxdataF_comp1, ul_ch_mag0, ul_ch_mag1, llr_layers0, rho0, nb_re); - nr_ulsch_qam16_qam16(rxdataF_comp1, rxdataF_comp0, ul_ch_mag1, ul_ch_mag0, llr_layers1, rho1, nb_re); - break; - case 6: - nr_ulsch_qam64_qam64(rxdataF_comp0, rxdataF_comp1, ul_ch_mag0, ul_ch_mag1, llr_layers0, rho0, nb_re); - nr_ulsch_qam64_qam64(rxdataF_comp1, rxdataF_comp0, ul_ch_mag1, ul_ch_mag0, llr_layers1, rho1, nb_re); - break; - default: - AssertFatal(1 == 0, "nr_ulsch_compute_llr: invalid Qm value, Qm = %d\n", mod_order); - } -} From 7e9968451f59ad4fd03777f542070390c0bef927 Mon Sep 17 00:00:00 2001 From: Quency Date: Wed, 12 Jul 2023 16:18:19 +0200 Subject: [PATCH 11/47] feat / Turn #define into static inline functions --- .../NR_TRANSPORT/nr_ulsch_llr_computation.c | 1604 +++++++---------- 1 file changed, 684 insertions(+), 920 deletions(-) diff --git a/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c b/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c index d8fe9c1048..d1735b5377 100644 --- a/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c +++ b/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c @@ -576,156 +576,176 @@ void nr_ulsch_qpsk_qpsk(c16_t *stream0_in, c16_t *stream1_in, c16_t *stream0_out static const int16_t ones[8] __attribute__((aligned(16))) = {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff}; -static const int16_t ones256[16] __attribute__((aligned(32))) = {0xffff, - 0xffff, - 0xffff, - 0xffff, - 0xffff, - 0xffff, - 0xffff, - 0xffff, - 0xffff, - 0xffff, - 0xffff, - 0xffff, - 0xffff, - 0xffff, - 0xffff, - 0xffff}; +static const int16_t ones256[16] __attribute__((aligned(32))) = {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, + 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff}; // calculate interference magnitude // tmp_result = ones in shorts corr. to interval 2<=x<=4, tmp_result2 interval < 2, tmp_result3 interval 46 -#define interference_abs_64qam_epi16(psi, int_ch_mag, int_two_ch_mag, int_three_ch_mag, a, c1, c3, c5, c7) \ - tmp_result = simde_mm_cmpgt_epi16(int_two_ch_mag, psi); \ - tmp_result3 = simde_mm_xor_si128(tmp_result, (*(simde__m128i *)&ones[0])); \ - tmp_result2 = simde_mm_cmpgt_epi16(int_ch_mag, psi); \ - tmp_result = simde_mm_xor_si128(tmp_result, tmp_result2); \ - tmp_result4 = simde_mm_cmpgt_epi16(psi, int_three_ch_mag); \ - tmp_result3 = simde_mm_xor_si128(tmp_result3, tmp_result4); \ - tmp_result = simde_mm_and_si128(tmp_result, c3); \ - tmp_result2 = simde_mm_and_si128(tmp_result2, c1); \ - tmp_result3 = simde_mm_and_si128(tmp_result3, c5); \ - tmp_result4 = simde_mm_and_si128(tmp_result4, c7); \ - tmp_result = simde_mm_or_si128(tmp_result, tmp_result2); \ - tmp_result3 = simde_mm_or_si128(tmp_result3, tmp_result4); \ - const simde__m128i a = simde_mm_or_si128(tmp_result, tmp_result3); +static inline simde__m128i interference_abs_64qam_epi16(simde__m128i psi, + simde__m128i int_ch_mag, + simde__m128i int_two_ch_mag, + simde__m128i int_three_ch_mag, + simde__m128i c1, + simde__m128i c3, + simde__m128i c5, + simde__m128i c7) +{ + simde__m128i tmp_result = simde_mm_cmpgt_epi16(int_two_ch_mag, psi); + simde__m128i tmp_result3 = simde_mm_xor_si128(tmp_result, (*(simde__m128i *)&ones[0])); + simde__m128i tmp_result2 = simde_mm_cmpgt_epi16(int_ch_mag, psi); + tmp_result = simde_mm_xor_si128(tmp_result, tmp_result2); + simde__m128i tmp_result4 = simde_mm_cmpgt_epi16(psi, int_three_ch_mag); + tmp_result3 = simde_mm_xor_si128(tmp_result3, tmp_result4); + tmp_result = simde_mm_and_si128(tmp_result, c3); + tmp_result2 = simde_mm_and_si128(tmp_result2, c1); + tmp_result3 = simde_mm_and_si128(tmp_result3, c5); + tmp_result4 = simde_mm_and_si128(tmp_result4, c7); + tmp_result = simde_mm_or_si128(tmp_result, tmp_result2); + tmp_result3 = simde_mm_or_si128(tmp_result3, tmp_result4); + return simde_mm_or_si128(tmp_result, tmp_result3); +} // calculate interference magnitude // tmp_result = ones in shorts corr. to interval 2<=x<=4, tmp_result2 interval < 2, tmp_result3 interval 46 -#define interference_abs_64qam_epi16_256(psi, int_ch_mag, int_two_ch_mag, int_three_ch_mag, a, c1, c3, c5, c7) \ - tmp_result = simde_mm256_cmpgt_epi16(int_two_ch_mag, psi); \ - tmp_result3 = simde_mm256_xor_si256(tmp_result, (*(simde__m256i *)&ones256[0])); \ - tmp_result2 = simde_mm256_cmpgt_epi16(int_ch_mag, psi); \ - tmp_result = simde_mm256_xor_si256(tmp_result, tmp_result2); \ - tmp_result4 = simde_mm256_cmpgt_epi16(psi, int_three_ch_mag); \ - tmp_result3 = simde_mm256_xor_si256(tmp_result3, tmp_result4); \ - tmp_result = simde_mm256_and_si256(tmp_result, c3); \ - tmp_result2 = simde_mm256_and_si256(tmp_result2, c1); \ - tmp_result3 = simde_mm256_and_si256(tmp_result3, c5); \ - tmp_result4 = simde_mm256_and_si256(tmp_result4, c7); \ - tmp_result = simde_mm256_or_si256(tmp_result, tmp_result2); \ - tmp_result3 = simde_mm256_or_si256(tmp_result3, tmp_result4); \ - const simde__m256i a = simde_mm256_or_si256(tmp_result, tmp_result3); +static inline simde__m256i interference_abs_64qam_epi16_256(simde__m256i psi, + simde__m256i int_ch_mag, + simde__m256i int_two_ch_mag, + simde__m256i int_three_ch_mag, + simde__m256i c1, + simde__m256i c3, + simde__m256i c5, + simde__m256i c7) +{ + simde__m256i tmp_result = simde_mm256_cmpgt_epi16(int_two_ch_mag, psi); + simde__m256i tmp_result3 = simde_mm256_xor_si256(tmp_result, (*(simde__m256i *)&ones256[0])); + simde__m256i tmp_result2 = simde_mm256_cmpgt_epi16(int_ch_mag, psi); + tmp_result = simde_mm256_xor_si256(tmp_result, tmp_result2); + simde__m256i tmp_result4 = simde_mm256_cmpgt_epi16(psi, int_three_ch_mag); + tmp_result3 = simde_mm256_xor_si256(tmp_result3, tmp_result4); + tmp_result = simde_mm256_and_si256(tmp_result, c3); + tmp_result2 = simde_mm256_and_si256(tmp_result2, c1); + tmp_result3 = simde_mm256_and_si256(tmp_result3, c5); + tmp_result4 = simde_mm256_and_si256(tmp_result4, c7); + tmp_result = simde_mm256_or_si256(tmp_result, tmp_result2); + tmp_result3 = simde_mm256_or_si256(tmp_result3, tmp_result4); + return simde_mm256_or_si256(tmp_result, tmp_result3); +} // Calculates psi_a = psi_r * a_r + psi_i * a_i -#define prodsum_psi_a_epi16(psi_r, a_r, psi_i, a_i, psi_a) \ - tmp_result = simde_mm_mulhi_epi16(psi_r, a_r); \ - tmp_result = simde_mm_slli_epi16(tmp_result, 1); \ - tmp_result2 = simde_mm_mulhi_epi16(psi_i, a_i); \ - tmp_result2 = simde_mm_slli_epi16(tmp_result2, 1); \ - simde__m128i psi_a = simde_mm_adds_epi16(tmp_result, tmp_result2); +static inline simde__m128i prodsum_psi_a_epi16(simde__m128i psi_r, simde__m128i a_r, simde__m128i psi_i, simde__m128i a_i) +{ + simde__m128i tmp_result = simde_mm_mulhi_epi16(psi_r, a_r); + tmp_result = simde_mm_slli_epi16(tmp_result, 1); + simde__m128i tmp_result2 = simde_mm_mulhi_epi16(psi_i, a_i); + tmp_result2 = simde_mm_slli_epi16(tmp_result2, 1); + return simde_mm_adds_epi16(tmp_result, tmp_result2); +} // calculates psi_a = psi_r*a_r + psi_i*a_i -#define prodsum_psi_a_epi16_256(psi_r, a_r, psi_i, a_i, psi_a) \ - tmp_result = simde_mm256_mulhi_epi16(psi_r, a_r); \ - tmp_result = simde_mm256_slli_epi16(tmp_result, 1); \ - tmp_result2 = simde_mm256_mulhi_epi16(psi_i, a_i); \ - tmp_result2 = simde_mm256_slli_epi16(tmp_result2, 1); \ - simde__m256i psi_a = simde_mm256_adds_epi16(tmp_result, tmp_result2); +static inline simde__m256i prodsum_psi_a_epi16_256(simde__m256i psi_r, simde__m256i a_r, simde__m256i psi_i, simde__m256i a_i) +{ + simde__m256i tmp_result = simde_mm256_mulhi_epi16(psi_r, a_r); + tmp_result = simde_mm256_slli_epi16(tmp_result, 1); + simde__m256i tmp_result2 = simde_mm256_mulhi_epi16(psi_i, a_i); + tmp_result2 = simde_mm256_slli_epi16(tmp_result2, 1); + return simde_mm256_adds_epi16(tmp_result, tmp_result2); +} // Calculate interference magnitude -#define interference_abs_epi16(psi, int_ch_mag, int_mag, c1, c2) \ - tmp_result = simde_mm_cmplt_epi16(psi, int_ch_mag); \ - tmp_result2 = simde_mm_xor_si128(tmp_result, (*(simde__m128i *)&ones[0])); \ - tmp_result = simde_mm_and_si128(tmp_result, c1); \ - tmp_result2 = simde_mm_and_si128(tmp_result2, c2); \ +static inline void interference_abs_epi16(simde__m128i psi, simde__m128i int_ch_mag, simde__m128i int_mag, simde__m128i c1, simde__m128i c2) +{ + simde__m128i tmp_result = simde_mm_cmplt_epi16(psi, int_ch_mag); + simde__m128i tmp_result2 = simde_mm_xor_si128(tmp_result, (*(simde__m128i *)&ones[0])); + tmp_result = simde_mm_and_si128(tmp_result, c1); + tmp_result2 = simde_mm_and_si128(tmp_result2, c2); int_mag = simde_mm_or_si128(tmp_result, tmp_result2); +} // Calculate interference magnitude -#define interference_abs_epi16_256(psi, int_ch_mag, int_mag, c1, c2) \ - tmp_result = simde_mm256_cmpgt_epi16(int_ch_mag, psi); \ - tmp_result2 = simde_mm256_xor_si256(tmp_result, (*(simde__m256i *)&ones256[0])); \ - tmp_result = simde_mm256_and_si256(tmp_result, c1); \ - tmp_result2 = simde_mm256_and_si256(tmp_result2, c2); \ +static inline void interference_abs_epi16_256(simde__m256i psi, simde__m256i int_ch_mag, simde__m256i int_mag, simde__m256i c1, simde__m256i c2) +{ + simde__m256i tmp_result = simde_mm256_cmpgt_epi16(int_ch_mag, psi); + simde__m256i tmp_result2 = simde_mm256_xor_si256(tmp_result, (*(simde__m256i *)&ones256[0])); + tmp_result = simde_mm256_and_si256(tmp_result, c1); + tmp_result2 = simde_mm256_and_si256(tmp_result2, c2); int_mag = simde_mm256_or_si256(tmp_result, tmp_result2); +} // Calculates a_sq = int_ch_mag * (a_r^2 + a_i^2) * scale_factor -#define square_a_epi16(a_r, a_i, int_ch_mag, scale_factor, a_sq) \ - tmp_result = simde_mm_mulhi_epi16(a_r, a_r); \ - tmp_result = simde_mm_slli_epi16(tmp_result, 1); \ - tmp_result = simde_mm_mulhi_epi16(tmp_result, scale_factor); \ - tmp_result = simde_mm_slli_epi16(tmp_result, 1); \ - tmp_result = simde_mm_mulhi_epi16(tmp_result, int_ch_mag); \ - tmp_result = simde_mm_slli_epi16(tmp_result, 1); \ - tmp_result2 = simde_mm_mulhi_epi16(a_i, a_i); \ - tmp_result2 = simde_mm_slli_epi16(tmp_result2, 1); \ - tmp_result2 = simde_mm_mulhi_epi16(tmp_result2, scale_factor); \ - tmp_result2 = simde_mm_slli_epi16(tmp_result2, 1); \ - tmp_result2 = simde_mm_mulhi_epi16(tmp_result2, int_ch_mag); \ - tmp_result2 = simde_mm_slli_epi16(tmp_result2, 1); \ +static inline void square_a_epi16(simde__m128i a_r, simde__m128i a_i, simde__m128i int_ch_mag, simde__m128i scale_factor, simde__m128i a_sq) +{ + simde__m128i tmp_result = simde_mm_mulhi_epi16(a_r, a_r); + tmp_result = simde_mm_slli_epi16(tmp_result, 1); + tmp_result = simde_mm_mulhi_epi16(tmp_result, scale_factor); + tmp_result = simde_mm_slli_epi16(tmp_result, 1); + tmp_result = simde_mm_mulhi_epi16(tmp_result, int_ch_mag); + tmp_result = simde_mm_slli_epi16(tmp_result, 1); + simde__m128i tmp_result2 = simde_mm_mulhi_epi16(a_i, a_i); + tmp_result2 = simde_mm_slli_epi16(tmp_result2, 1); + tmp_result2 = simde_mm_mulhi_epi16(tmp_result2, scale_factor); + tmp_result2 = simde_mm_slli_epi16(tmp_result2, 1); + tmp_result2 = simde_mm_mulhi_epi16(tmp_result2, int_ch_mag); + tmp_result2 = simde_mm_slli_epi16(tmp_result2, 1); a_sq = simde_mm_adds_epi16(tmp_result, tmp_result2); +} // Calculates a_sq = int_ch_mag * (a_r^2 + a_i^2) * scale_factor -#define square_a_epi16_256(a_r, a_i, int_ch_mag, scale_factor, a_sq) \ - tmp_result = simde_mm256_mulhi_epi16(a_r, a_r); \ - tmp_result = simde_mm256_slli_epi16(tmp_result, 1); \ - tmp_result = simde_mm256_mulhi_epi16(tmp_result, scale_factor); \ - tmp_result = simde_mm256_slli_epi16(tmp_result, 1); \ - tmp_result = simde_mm256_mulhi_epi16(tmp_result, int_ch_mag); \ - tmp_result = simde_mm256_slli_epi16(tmp_result, 1); \ - tmp_result2 = simde_mm256_mulhi_epi16(a_i, a_i); \ - tmp_result2 = simde_mm256_slli_epi16(tmp_result2, 1); \ - tmp_result2 = simde_mm256_mulhi_epi16(tmp_result2, scale_factor); \ - tmp_result2 = simde_mm256_slli_epi16(tmp_result2, 1); \ - tmp_result2 = simde_mm256_mulhi_epi16(tmp_result2, int_ch_mag); \ - tmp_result2 = simde_mm256_slli_epi16(tmp_result2, 1); \ +static inline void square_a_epi16_256(simde__m256i a_r, simde__m256i a_i, simde__m256i int_ch_mag, simde__m256i scale_factor, simde__m256i a_sq) +{ + simde__m256i tmp_result = simde_mm256_mulhi_epi16(a_r, a_r); + tmp_result = simde_mm256_slli_epi16(tmp_result, 1); + tmp_result = simde_mm256_mulhi_epi16(tmp_result, scale_factor); + tmp_result = simde_mm256_slli_epi16(tmp_result, 1); + tmp_result = simde_mm256_mulhi_epi16(tmp_result, int_ch_mag); + tmp_result = simde_mm256_slli_epi16(tmp_result, 1); + simde__m256i tmp_result2 = simde_mm256_mulhi_epi16(a_i, a_i); + tmp_result2 = simde_mm256_slli_epi16(tmp_result2, 1); + tmp_result2 = simde_mm256_mulhi_epi16(tmp_result2, scale_factor); + tmp_result2 = simde_mm256_slli_epi16(tmp_result2, 1); + tmp_result2 = simde_mm256_mulhi_epi16(tmp_result2, int_ch_mag); + tmp_result2 = simde_mm256_slli_epi16(tmp_result2, 1); a_sq = simde_mm256_adds_epi16(tmp_result, tmp_result2); +} // calculates a_sq = int_ch_mag*(a_r^2 + a_i^2)*scale_factor for 64-QAM -#define square_a_64qam_epi16(a_r, a_i, int_ch_mag, scale_factor, a_sq) \ - tmp_result = simde_mm_mulhi_epi16(a_r, a_r); \ - tmp_result = simde_mm_slli_epi16(tmp_result, 1); \ - tmp_result = simde_mm_mulhi_epi16(tmp_result, scale_factor); \ - tmp_result = simde_mm_slli_epi16(tmp_result, 3); \ - tmp_result = simde_mm_mulhi_epi16(tmp_result, int_ch_mag); \ - tmp_result = simde_mm_slli_epi16(tmp_result, 1); \ - tmp_result2 = simde_mm_mulhi_epi16(a_i, a_i); \ - tmp_result2 = simde_mm_slli_epi16(tmp_result2, 1); \ - tmp_result2 = simde_mm_mulhi_epi16(tmp_result2, scale_factor); \ - tmp_result2 = simde_mm_slli_epi16(tmp_result2, 3); \ - tmp_result2 = simde_mm_mulhi_epi16(tmp_result2, int_ch_mag); \ - tmp_result2 = simde_mm_slli_epi16(tmp_result2, 1); \ - const simde__m128i a_sq = simde_mm_adds_epi16(tmp_result, tmp_result2); +static inline simde__m128i square_a_64qam_epi16(simde__m128i a_r, simde__m128i a_i, simde__m128i int_ch_mag, simde__m128i scale_factor) +{ + simde__m128i tmp_result = simde_mm_mulhi_epi16(a_r, a_r); + tmp_result = simde_mm_slli_epi16(tmp_result, 1); + tmp_result = simde_mm_mulhi_epi16(tmp_result, scale_factor); + tmp_result = simde_mm_slli_epi16(tmp_result, 3); + tmp_result = simde_mm_mulhi_epi16(tmp_result, int_ch_mag); + tmp_result = simde_mm_slli_epi16(tmp_result, 1); + simde__m128i tmp_result2 = simde_mm_mulhi_epi16(a_i, a_i); + tmp_result2 = simde_mm_slli_epi16(tmp_result2, 1); + tmp_result2 = simde_mm_mulhi_epi16(tmp_result2, scale_factor); + tmp_result2 = simde_mm_slli_epi16(tmp_result2, 3); + tmp_result2 = simde_mm_mulhi_epi16(tmp_result2, int_ch_mag); + tmp_result2 = simde_mm_slli_epi16(tmp_result2, 1); + return simde_mm_adds_epi16(tmp_result, tmp_result2); +} // calculates a_sq = int_ch_mag*(a_r^2 + a_i^2)*scale_factor for 64-QAM -#define square_a_64qam_epi16_256(a_r, a_i, int_ch_mag, scale_factor, a_sq) \ - tmp_result = simde_mm256_mulhi_epi16(a_r, a_r); \ - tmp_result = simde_mm256_slli_epi16(tmp_result, 1); \ - tmp_result = simde_mm256_mulhi_epi16(tmp_result, scale_factor); \ - tmp_result = simde_mm256_slli_epi16(tmp_result, 3); \ - tmp_result = simde_mm256_mulhi_epi16(tmp_result, int_ch_mag); \ - tmp_result = simde_mm256_slli_epi16(tmp_result, 1); \ - tmp_result2 = simde_mm256_mulhi_epi16(a_i, a_i); \ - tmp_result2 = simde_mm256_slli_epi16(tmp_result2, 1); \ - tmp_result2 = simde_mm256_mulhi_epi16(tmp_result2, scale_factor); \ - tmp_result2 = simde_mm256_slli_epi16(tmp_result2, 3); \ - tmp_result2 = simde_mm256_mulhi_epi16(tmp_result2, int_ch_mag); \ - tmp_result2 = simde_mm256_slli_epi16(tmp_result2, 1); \ - const simde__m256i a_sq = simde_mm256_adds_epi16(tmp_result, tmp_result2); +static inline simde__m256i square_a_64qam_epi16_256(simde__m256i a_r, simde__m256i a_i, simde__m256i int_ch_mag, simde__m256i scale_factor) +{ + simde__m256i tmp_result = simde_mm256_mulhi_epi16(a_r, a_r); + tmp_result = simde_mm256_slli_epi16(tmp_result, 1); + tmp_result = simde_mm256_mulhi_epi16(tmp_result, scale_factor); + tmp_result = simde_mm256_slli_epi16(tmp_result, 3); + tmp_result = simde_mm256_mulhi_epi16(tmp_result, int_ch_mag); + tmp_result = simde_mm256_slli_epi16(tmp_result, 1); + simde__m256i tmp_result2 = simde_mm256_mulhi_epi16(a_i, a_i); + tmp_result2 = simde_mm256_slli_epi16(tmp_result2, 1); + tmp_result2 = simde_mm256_mulhi_epi16(tmp_result2, scale_factor); + tmp_result2 = simde_mm256_slli_epi16(tmp_result2, 3); + tmp_result2 = simde_mm256_mulhi_epi16(tmp_result2, int_ch_mag); + tmp_result2 = simde_mm256_slli_epi16(tmp_result2, 1); + return simde_mm256_adds_epi16(tmp_result, tmp_result2); +} simde__m128i max_epi16(simde__m128i m0, simde__m128i m1, simde__m128i m2, simde__m128i m3, simde__m128i m4, simde__m128i m5, simde__m128i m6, simde__m128i m7) { @@ -1100,22 +1120,22 @@ void nr_ulsch_qam16_qam16(c16_t *stream0_in, interference_abs_epi16(psi_i_m3_m3, ch_mag_int, a_i_m3_m3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); // Calculation of groups of two terms in the bit metric involving product of psi and interference magnitude - prodsum_psi_a_epi16(psi_r_p1_p1, a_r_p1_p1, psi_i_p1_p1, a_i_p1_p1, psi_a_p1_p1); - prodsum_psi_a_epi16(psi_r_p1_p3, a_r_p1_p3, psi_i_p1_p3, a_i_p1_p3, psi_a_p1_p3); - prodsum_psi_a_epi16(psi_r_p3_p1, a_r_p3_p1, psi_i_p3_p1, a_i_p3_p1, psi_a_p3_p1); - prodsum_psi_a_epi16(psi_r_p3_p3, a_r_p3_p3, psi_i_p3_p3, a_i_p3_p3, psi_a_p3_p3); - prodsum_psi_a_epi16(psi_r_p1_m1, a_r_p1_m1, psi_i_p1_m1, a_i_p1_m1, psi_a_p1_m1); - prodsum_psi_a_epi16(psi_r_p1_m3, a_r_p1_m3, psi_i_p1_m3, a_i_p1_m3, psi_a_p1_m3); - prodsum_psi_a_epi16(psi_r_p3_m1, a_r_p3_m1, psi_i_p3_m1, a_i_p3_m1, psi_a_p3_m1); - prodsum_psi_a_epi16(psi_r_p3_m3, a_r_p3_m3, psi_i_p3_m3, a_i_p3_m3, psi_a_p3_m3); - prodsum_psi_a_epi16(psi_r_m1_p1, a_r_m1_p1, psi_i_m1_p1, a_i_m1_p1, psi_a_m1_p1); - prodsum_psi_a_epi16(psi_r_m1_p3, a_r_m1_p3, psi_i_m1_p3, a_i_m1_p3, psi_a_m1_p3); - prodsum_psi_a_epi16(psi_r_m3_p1, a_r_m3_p1, psi_i_m3_p1, a_i_m3_p1, psi_a_m3_p1); - prodsum_psi_a_epi16(psi_r_m3_p3, a_r_m3_p3, psi_i_m3_p3, a_i_m3_p3, psi_a_m3_p3); - prodsum_psi_a_epi16(psi_r_m1_m1, a_r_m1_m1, psi_i_m1_m1, a_i_m1_m1, psi_a_m1_m1); - prodsum_psi_a_epi16(psi_r_m1_m3, a_r_m1_m3, psi_i_m1_m3, a_i_m1_m3, psi_a_m1_m3); - prodsum_psi_a_epi16(psi_r_m3_m1, a_r_m3_m1, psi_i_m3_m1, a_i_m3_m1, psi_a_m3_m1); - prodsum_psi_a_epi16(psi_r_m3_m3, a_r_m3_m3, psi_i_m3_m3, a_i_m3_m3, psi_a_m3_m3); + simde__m128i psi_a_p1_p1 = prodsum_psi_a_epi16(psi_r_p1_p1, a_r_p1_p1, psi_i_p1_p1, a_i_p1_p1); + simde__m128i psi_a_p1_p3 = prodsum_psi_a_epi16(psi_r_p1_p3, a_r_p1_p3, psi_i_p1_p3, a_i_p1_p3); + simde__m128i psi_a_p3_p1 = prodsum_psi_a_epi16(psi_r_p3_p1, a_r_p3_p1, psi_i_p3_p1, a_i_p3_p1); + simde__m128i psi_a_p3_p3 = prodsum_psi_a_epi16(psi_r_p3_p3, a_r_p3_p3, psi_i_p3_p3, a_i_p3_p3); + simde__m128i psi_a_p1_m1 = prodsum_psi_a_epi16(psi_r_p1_m1, a_r_p1_m1, psi_i_p1_m1, a_i_p1_m1); + simde__m128i psi_a_p1_m3 = prodsum_psi_a_epi16(psi_r_p1_m3, a_r_p1_m3, psi_i_p1_m3, a_i_p1_m3); + simde__m128i psi_a_p3_m1 = prodsum_psi_a_epi16(psi_r_p3_m1, a_r_p3_m1, psi_i_p3_m1, a_i_p3_m1); + simde__m128i psi_a_p3_m3 = prodsum_psi_a_epi16(psi_r_p3_m3, a_r_p3_m3, psi_i_p3_m3, a_i_p3_m3); + simde__m128i psi_a_m1_p1 = prodsum_psi_a_epi16(psi_r_m1_p1, a_r_m1_p1, psi_i_m1_p1, a_i_m1_p1); + simde__m128i psi_a_m1_p3 = prodsum_psi_a_epi16(psi_r_m1_p3, a_r_m1_p3, psi_i_m1_p3, a_i_m1_p3); + simde__m128i psi_a_m3_p1 = prodsum_psi_a_epi16(psi_r_m3_p1, a_r_m3_p1, psi_i_m3_p1, a_i_m3_p1); + simde__m128i psi_a_m3_p3 = prodsum_psi_a_epi16(psi_r_m3_p3, a_r_m3_p3, psi_i_m3_p3, a_i_m3_p3); + simde__m128i psi_a_m1_m1 = prodsum_psi_a_epi16(psi_r_m1_m1, a_r_m1_m1, psi_i_m1_m1, a_i_m1_m1); + simde__m128i psi_a_m1_m3 = prodsum_psi_a_epi16(psi_r_m1_m3, a_r_m1_m3, psi_i_m1_m3, a_i_m1_m3); + simde__m128i psi_a_m3_m1 = prodsum_psi_a_epi16(psi_r_m3_m1, a_r_m3_m1, psi_i_m3_m1, a_i_m3_m1); + simde__m128i psi_a_m3_m3 = prodsum_psi_a_epi16(psi_r_m3_m3, a_r_m3_m3, psi_i_m3_m3, a_i_m3_m3); // squared interference magnitude times int. ch. power square_a_epi16(a_r_p1_p1, a_i_p1_p1, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_p1_p1); @@ -1635,22 +1655,22 @@ void nr_ulsch_qam16_qam16(c16_t *stream0_in, interference_abs_epi16_256(psi_i_m3_m3, ch_mag_int, a_i_m3_m3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); // Calculation of groups of two terms in the bit metric involving product of psi and interference magnitude - prodsum_psi_a_epi16_256(psi_r_p1_p1, a_r_p1_p1, psi_i_p1_p1, a_i_p1_p1, psi_a_p1_p1); - prodsum_psi_a_epi16_256(psi_r_p1_p3, a_r_p1_p3, psi_i_p1_p3, a_i_p1_p3, psi_a_p1_p3); - prodsum_psi_a_epi16_256(psi_r_p3_p1, a_r_p3_p1, psi_i_p3_p1, a_i_p3_p1, psi_a_p3_p1); - prodsum_psi_a_epi16_256(psi_r_p3_p3, a_r_p3_p3, psi_i_p3_p3, a_i_p3_p3, psi_a_p3_p3); - prodsum_psi_a_epi16_256(psi_r_p1_m1, a_r_p1_m1, psi_i_p1_m1, a_i_p1_m1, psi_a_p1_m1); - prodsum_psi_a_epi16_256(psi_r_p1_m3, a_r_p1_m3, psi_i_p1_m3, a_i_p1_m3, psi_a_p1_m3); - prodsum_psi_a_epi16_256(psi_r_p3_m1, a_r_p3_m1, psi_i_p3_m1, a_i_p3_m1, psi_a_p3_m1); - prodsum_psi_a_epi16_256(psi_r_p3_m3, a_r_p3_m3, psi_i_p3_m3, a_i_p3_m3, psi_a_p3_m3); - prodsum_psi_a_epi16_256(psi_r_m1_p1, a_r_m1_p1, psi_i_m1_p1, a_i_m1_p1, psi_a_m1_p1); - prodsum_psi_a_epi16_256(psi_r_m1_p3, a_r_m1_p3, psi_i_m1_p3, a_i_m1_p3, psi_a_m1_p3); - prodsum_psi_a_epi16_256(psi_r_m3_p1, a_r_m3_p1, psi_i_m3_p1, a_i_m3_p1, psi_a_m3_p1); - prodsum_psi_a_epi16_256(psi_r_m3_p3, a_r_m3_p3, psi_i_m3_p3, a_i_m3_p3, psi_a_m3_p3); - prodsum_psi_a_epi16_256(psi_r_m1_m1, a_r_m1_m1, psi_i_m1_m1, a_i_m1_m1, psi_a_m1_m1); - prodsum_psi_a_epi16_256(psi_r_m1_m3, a_r_m1_m3, psi_i_m1_m3, a_i_m1_m3, psi_a_m1_m3); - prodsum_psi_a_epi16_256(psi_r_m3_m1, a_r_m3_m1, psi_i_m3_m1, a_i_m3_m1, psi_a_m3_m1); - prodsum_psi_a_epi16_256(psi_r_m3_m3, a_r_m3_m3, psi_i_m3_m3, a_i_m3_m3, psi_a_m3_m3); + simde__m256i psi_a_p1_p1 = prodsum_psi_a_epi16_256(psi_r_p1_p1, a_r_p1_p1, psi_i_p1_p1, a_i_p1_p1); + simde__m256i psi_a_p1_p3 = prodsum_psi_a_epi16_256(psi_r_p1_p3, a_r_p1_p3, psi_i_p1_p3, a_i_p1_p3); + simde__m256i psi_a_p3_p1 = prodsum_psi_a_epi16_256(psi_r_p3_p1, a_r_p3_p1, psi_i_p3_p1, a_i_p3_p1); + simde__m256i psi_a_p3_p3 = prodsum_psi_a_epi16_256(psi_r_p3_p3, a_r_p3_p3, psi_i_p3_p3, a_i_p3_p3); + simde__m256i psi_a_p1_m1 = prodsum_psi_a_epi16_256(psi_r_p1_m1, a_r_p1_m1, psi_i_p1_m1, a_i_p1_m1); + simde__m256i psi_a_p1_m3 = prodsum_psi_a_epi16_256(psi_r_p1_m3, a_r_p1_m3, psi_i_p1_m3, a_i_p1_m3); + simde__m256i psi_a_p3_m1 = prodsum_psi_a_epi16_256(psi_r_p3_m1, a_r_p3_m1, psi_i_p3_m1, a_i_p3_m1); + simde__m256i psi_a_p3_m3 = prodsum_psi_a_epi16_256(psi_r_p3_m3, a_r_p3_m3, psi_i_p3_m3, a_i_p3_m3); + simde__m256i psi_a_m1_p1 = prodsum_psi_a_epi16_256(psi_r_m1_p1, a_r_m1_p1, psi_i_m1_p1, a_i_m1_p1); + simde__m256i psi_a_m1_p3 = prodsum_psi_a_epi16_256(psi_r_m1_p3, a_r_m1_p3, psi_i_m1_p3, a_i_m1_p3); + simde__m256i psi_a_m3_p1 = prodsum_psi_a_epi16_256(psi_r_m3_p1, a_r_m3_p1, psi_i_m3_p1, a_i_m3_p1); + simde__m256i psi_a_m3_p3 = prodsum_psi_a_epi16_256(psi_r_m3_p3, a_r_m3_p3, psi_i_m3_p3, a_i_m3_p3); + simde__m256i psi_a_m1_m1 = prodsum_psi_a_epi16_256(psi_r_m1_m1, a_r_m1_m1, psi_i_m1_m1, a_i_m1_m1); + simde__m256i psi_a_m1_m3 = prodsum_psi_a_epi16_256(psi_r_m1_m3, a_r_m1_m3, psi_i_m1_m3, a_i_m1_m3); + simde__m256i psi_a_m3_m1 = prodsum_psi_a_epi16_256(psi_r_m3_m1, a_r_m3_m1, psi_i_m3_m1, a_i_m3_m1); + simde__m256i psi_a_m3_m3 = prodsum_psi_a_epi16_256(psi_r_m3_m3, a_r_m3_m3, psi_i_m3_m3, a_i_m3_m3); // squared interference magnitude times int. ch. power square_a_epi16_256(a_r_p1_p1, a_i_p1_p1, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_p1_p1); @@ -2333,1225 +2353,1097 @@ void nr_ulsch_qam64_qam64(c16_t *stream0_in, two_ch_mag_int_with_sigma2 = ch_mag_int; // *4 three_ch_mag_int_with_sigma2 = simde_mm_adds_epi16(ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2); // *6 simde__m128i tmp_result, tmp_result2, tmp_result3, tmp_result4; - interference_abs_64qam_epi16(psi_r_p7_p7, + simde__m128i a_r_p7_p7 = interference_abs_64qam_epi16(psi_r_p7_p7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p7_p7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_p7_p5, + simde__m128i a_r_p7_p5 = interference_abs_64qam_epi16(psi_r_p7_p5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p7_p5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_p7_p3, + simde__m128i a_r_p7_p3 = interference_abs_64qam_epi16(psi_r_p7_p3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p7_p3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_p7_p1, + simde__m128i a_r_p7_p1 = interference_abs_64qam_epi16(psi_r_p7_p1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p7_p1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_p7_m1, + simde__m128i a_r_p7_m1 = interference_abs_64qam_epi16(psi_r_p7_m1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p7_m1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_p7_m3, + simde__m128i a_r_p7_m3 = interference_abs_64qam_epi16(psi_r_p7_m3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p7_m3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_p7_m5, + simde__m128i a_r_p7_m5 = interference_abs_64qam_epi16(psi_r_p7_m5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p7_m5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_p7_m7, + simde__m128i a_r_p7_m7 = interference_abs_64qam_epi16(psi_r_p7_m7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p7_m7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_p5_p7, + simde__m128i a_r_p5_p7 = interference_abs_64qam_epi16(psi_r_p5_p7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p5_p7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_p5_p5, + simde__m128i a_r_p5_p5 = interference_abs_64qam_epi16(psi_r_p5_p5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p5_p5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_p5_p3, + simde__m128i a_r_p5_p3 = interference_abs_64qam_epi16(psi_r_p5_p3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p5_p3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_p5_p1, + simde__m128i a_r_p5_p1 = interference_abs_64qam_epi16(psi_r_p5_p1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p5_p1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_p5_m1, + simde__m128i a_r_p5_m1 = interference_abs_64qam_epi16(psi_r_p5_m1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p5_m1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_p5_m3, + simde__m128i a_r_p5_m3 = interference_abs_64qam_epi16(psi_r_p5_m3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p5_m3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_p5_m5, + simde__m128i a_r_p5_m5 = interference_abs_64qam_epi16(psi_r_p5_m5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p5_m5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_p5_m7, + simde__m128i a_r_p5_m7 = interference_abs_64qam_epi16(psi_r_p5_m7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p5_m7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_p3_p7, + simde__m128i a_r_p3_p7 = interference_abs_64qam_epi16(psi_r_p3_p7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p3_p7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_p3_p5, + simde__m128i a_r_p3_p5 = interference_abs_64qam_epi16(psi_r_p3_p5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p3_p5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_p3_p3, + simde__m128i a_r_p3_p3 = interference_abs_64qam_epi16(psi_r_p3_p3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p3_p3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_p3_p1, + simde__m128i a_r_p3_p1 = interference_abs_64qam_epi16(psi_r_p3_p1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p3_p1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_p3_m1, + simde__m128i a_r_p3_m1 = interference_abs_64qam_epi16(psi_r_p3_m1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p3_m1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_p3_m3, + simde__m128i a_r_p3_m3 = interference_abs_64qam_epi16(psi_r_p3_m3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p3_m3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_p3_m5, + simde__m128i a_r_p3_m5 = interference_abs_64qam_epi16(psi_r_p3_m5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p3_m5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_p3_m7, + simde__m128i a_r_p3_m7 = interference_abs_64qam_epi16(psi_r_p3_m7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p3_m7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_p1_p7, + simde__m128i a_r_p1_p7 = interference_abs_64qam_epi16(psi_r_p1_p7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p1_p7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_p1_p5, + simde__m128i a_r_p1_p5 = interference_abs_64qam_epi16(psi_r_p1_p5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p1_p5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_p1_p3, + simde__m128i a_r_p1_p3 = interference_abs_64qam_epi16(psi_r_p1_p3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p1_p3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_p1_p1, + simde__m128i a_r_p1_p1 = interference_abs_64qam_epi16(psi_r_p1_p1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p1_p1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_p1_m1, + simde__m128i a_r_p1_m1 = interference_abs_64qam_epi16(psi_r_p1_m1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p1_m1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_p1_m3, + simde__m128i a_r_p1_m3 = interference_abs_64qam_epi16(psi_r_p1_m3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p1_m3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_p1_m5, + simde__m128i a_r_p1_m5 = interference_abs_64qam_epi16(psi_r_p1_m5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p1_m5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_p1_m7, + simde__m128i a_r_p1_m7 = interference_abs_64qam_epi16(psi_r_p1_m7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p1_m7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_m1_p7, + simde__m128i a_r_m1_p7 = interference_abs_64qam_epi16(psi_r_m1_p7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m1_p7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_m1_p5, + simde__m128i a_r_m1_p5 = interference_abs_64qam_epi16(psi_r_m1_p5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m1_p5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_m1_p3, + simde__m128i a_r_m1_p3 = interference_abs_64qam_epi16(psi_r_m1_p3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m1_p3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_m1_p1, + simde__m128i a_r_m1_p1 = interference_abs_64qam_epi16(psi_r_m1_p1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m1_p1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_m1_m1, + simde__m128i a_r_m1_m1 = interference_abs_64qam_epi16(psi_r_m1_m1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m1_m1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_m1_m3, + simde__m128i a_r_m1_m3 = interference_abs_64qam_epi16(psi_r_m1_m3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m1_m3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_m1_m5, + simde__m128i a_r_m1_m5 = interference_abs_64qam_epi16(psi_r_m1_m5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m1_m5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_m1_m7, + simde__m128i a_r_m1_m7 = interference_abs_64qam_epi16(psi_r_m1_m7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m1_m7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_m3_p7, + simde__m128i a_r_m3_p7 = interference_abs_64qam_epi16(psi_r_m3_p7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m3_p7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_m3_p5, + simde__m128i a_r_m3_p5 = interference_abs_64qam_epi16(psi_r_m3_p5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m3_p5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_m3_p3, + simde__m128i a_r_m3_p3 = interference_abs_64qam_epi16(psi_r_m3_p3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m3_p3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_m3_p1, + simde__m128i a_r_m3_p1 = interference_abs_64qam_epi16(psi_r_m3_p1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m3_p1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_m3_m1, + simde__m128i a_r_m3_m1 = interference_abs_64qam_epi16(psi_r_m3_m1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m3_m1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_m3_m3, + simde__m128i a_r_m3_m3 = interference_abs_64qam_epi16(psi_r_m3_m3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m3_m3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_m3_m5, + simde__m128i a_r_m3_m5 = interference_abs_64qam_epi16(psi_r_m3_m5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m3_m5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_m3_m7, + simde__m128i a_r_m3_m7 = interference_abs_64qam_epi16(psi_r_m3_m7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m3_m7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_m5_p7, + simde__m128i a_r_m5_p7 = interference_abs_64qam_epi16(psi_r_m5_p7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m5_p7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_m5_p5, + simde__m128i a_r_m5_p5 = interference_abs_64qam_epi16(psi_r_m5_p5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m5_p5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_m5_p3, + simde__m128i a_r_m5_p3 = interference_abs_64qam_epi16(psi_r_m5_p3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m5_p3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_m5_p1, + simde__m128i a_r_m5_p1 = interference_abs_64qam_epi16(psi_r_m5_p1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m5_p1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_m5_m1, + simde__m128i a_r_m5_m1 = interference_abs_64qam_epi16(psi_r_m5_m1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m5_m1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_m5_m3, + simde__m128i a_r_m5_m3 = interference_abs_64qam_epi16(psi_r_m5_m3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m5_m3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_m5_m5, + simde__m128i a_r_m5_m5 = interference_abs_64qam_epi16(psi_r_m5_m5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m5_m5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_m5_m7, + simde__m128i a_r_m5_m7 = interference_abs_64qam_epi16(psi_r_m5_m7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m5_m7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_m7_p7, + simde__m128i a_r_m7_p7 = interference_abs_64qam_epi16(psi_r_m7_p7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m7_p7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_m7_p5, + simde__m128i a_r_m7_p5 = interference_abs_64qam_epi16(psi_r_m7_p5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m7_p5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_m7_p3, + simde__m128i a_r_m7_p3 = interference_abs_64qam_epi16(psi_r_m7_p3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m7_p3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_m7_p1, + simde__m128i a_r_m7_p1 = interference_abs_64qam_epi16(psi_r_m7_p1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m7_p1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_m7_m1, + simde__m128i a_r_m7_m1 = interference_abs_64qam_epi16(psi_r_m7_m1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m7_m1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_m7_m3, + simde__m128i a_r_m7_m3 = interference_abs_64qam_epi16(psi_r_m7_m3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m7_m3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_m7_m5, + simde__m128i a_r_m7_m5 = interference_abs_64qam_epi16(psi_r_m7_m5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m7_m5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_r_m7_m7, + simde__m128i a_r_m7_m7 = interference_abs_64qam_epi16(psi_r_m7_m7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m7_m7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_p7_p7, + simde__m128i a_i_p7_p7 = interference_abs_64qam_epi16(psi_i_p7_p7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p7_p7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_p7_p5, + simde__m128i a_i_p7_p5 = interference_abs_64qam_epi16(psi_i_p7_p5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p7_p5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_p7_p3, + simde__m128i a_i_p7_p3 = interference_abs_64qam_epi16(psi_i_p7_p3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p7_p3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_p7_p1, + simde__m128i a_i_p7_p1 = interference_abs_64qam_epi16(psi_i_p7_p1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p7_p1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_p7_m1, + simde__m128i a_i_p7_m1 = interference_abs_64qam_epi16(psi_i_p7_m1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p7_m1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_p7_m3, + simde__m128i a_i_p7_m3 = interference_abs_64qam_epi16(psi_i_p7_m3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p7_m3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_p7_m5, + simde__m128i a_i_p7_m5 = interference_abs_64qam_epi16(psi_i_p7_m5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p7_m5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_p7_m7, + simde__m128i a_i_p7_m7 = interference_abs_64qam_epi16(psi_i_p7_m7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p7_m7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_p5_p7, + simde__m128i a_i_p5_p7 = interference_abs_64qam_epi16(psi_i_p5_p7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p5_p7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_p5_p5, + simde__m128i a_i_p5_p5 = interference_abs_64qam_epi16(psi_i_p5_p5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p5_p5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_p5_p3, + simde__m128i a_i_p5_p3 = interference_abs_64qam_epi16(psi_i_p5_p3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p5_p3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_p5_p1, + simde__m128i a_i_p5_p1 = interference_abs_64qam_epi16(psi_i_p5_p1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p5_p1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_p5_m1, + simde__m128i a_i_p5_m1 = interference_abs_64qam_epi16(psi_i_p5_m1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p5_m1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_p5_m3, + simde__m128i a_i_p5_m3 = interference_abs_64qam_epi16(psi_i_p5_m3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p5_m3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_p5_m5, + simde__m128i a_i_p5_m5 = interference_abs_64qam_epi16(psi_i_p5_m5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p5_m5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_p5_m7, + simde__m128i a_i_p5_m7 = interference_abs_64qam_epi16(psi_i_p5_m7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p5_m7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_p3_p7, + simde__m128i a_i_p3_p7 = interference_abs_64qam_epi16(psi_i_p3_p7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p3_p7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_p3_p5, + simde__m128i a_i_p3_p5 = interference_abs_64qam_epi16(psi_i_p3_p5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p3_p5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_p3_p3, + simde__m128i a_i_p3_p3 = interference_abs_64qam_epi16(psi_i_p3_p3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p3_p3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_p3_p1, + simde__m128i a_i_p3_p1 = interference_abs_64qam_epi16(psi_i_p3_p1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p3_p1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_p3_m1, + simde__m128i a_i_p3_m1 = interference_abs_64qam_epi16(psi_i_p3_m1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p3_m1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_p3_m3, + simde__m128i a_i_p3_m3 = interference_abs_64qam_epi16(psi_i_p3_m3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p3_m3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_p3_m5, + simde__m128i a_i_p3_m5 = interference_abs_64qam_epi16(psi_i_p3_m5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p3_m5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_p3_m7, + simde__m128i a_i_p3_m7 = interference_abs_64qam_epi16(psi_i_p3_m7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p3_m7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_p1_p7, + simde__m128i a_i_p1_p7 = interference_abs_64qam_epi16(psi_i_p1_p7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p1_p7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_p1_p5, + simde__m128i a_i_p1_p5 = interference_abs_64qam_epi16(psi_i_p1_p5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p1_p5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_p1_p3, + simde__m128i a_i_p1_p3 = interference_abs_64qam_epi16(psi_i_p1_p3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p1_p3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_p1_p1, + simde__m128i a_i_p1_p1 = interference_abs_64qam_epi16(psi_i_p1_p1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p1_p1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_p1_m1, + simde__m128i a_i_p1_m1 = interference_abs_64qam_epi16(psi_i_p1_m1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p1_m1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_p1_m3, + simde__m128i a_i_p1_m3 = interference_abs_64qam_epi16(psi_i_p1_m3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p1_m3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_p1_m5, + simde__m128i a_i_p1_m5 = interference_abs_64qam_epi16(psi_i_p1_m5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p1_m5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_p1_m7, + simde__m128i a_i_p1_m7 = interference_abs_64qam_epi16(psi_i_p1_m7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p1_m7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_m1_p7, + simde__m128i a_i_m1_p7 = interference_abs_64qam_epi16(psi_i_m1_p7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m1_p7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_m1_p5, + simde__m128i a_i_m1_p5 = interference_abs_64qam_epi16(psi_i_m1_p5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m1_p5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_m1_p3, + simde__m128i a_i_m1_p3 = interference_abs_64qam_epi16(psi_i_m1_p3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m1_p3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_m1_p1, + simde__m128i a_i_m1_p1 = interference_abs_64qam_epi16(psi_i_m1_p1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m1_p1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_m1_m1, + simde__m128i a_i_m1_m1 = interference_abs_64qam_epi16(psi_i_m1_m1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m1_m1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_m1_m3, + simde__m128i a_i_m1_m3 = interference_abs_64qam_epi16(psi_i_m1_m3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m1_m3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_m1_m5, + simde__m128i a_i_m1_m5 = interference_abs_64qam_epi16(psi_i_m1_m5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m1_m5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_m1_m7, + simde__m128i a_i_m1_m7 = interference_abs_64qam_epi16(psi_i_m1_m7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m1_m7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_m3_p7, + simde__m128i a_i_m3_p7 = interference_abs_64qam_epi16(psi_i_m3_p7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m3_p7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_m3_p5, + simde__m128i a_i_m3_p5 = interference_abs_64qam_epi16(psi_i_m3_p5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m3_p5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_m3_p3, + simde__m128i a_i_m3_p3 = interference_abs_64qam_epi16(psi_i_m3_p3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m3_p3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_m3_p1, + simde__m128i a_i_m3_p1 = interference_abs_64qam_epi16(psi_i_m3_p1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m3_p1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_m3_m1, + simde__m128i a_i_m3_m1 = interference_abs_64qam_epi16(psi_i_m3_m1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m3_m1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_m3_m3, + simde__m128i a_i_m3_m3 = interference_abs_64qam_epi16(psi_i_m3_m3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m3_m3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_m3_m5, + simde__m128i a_i_m3_m5 = interference_abs_64qam_epi16(psi_i_m3_m5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m3_m5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_m3_m7, + simde__m128i a_i_m3_m7 = interference_abs_64qam_epi16(psi_i_m3_m7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m3_m7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_m5_p7, + simde__m128i a_i_m5_p7 = interference_abs_64qam_epi16(psi_i_m5_p7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m5_p7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_m5_p5, + simde__m128i a_i_m5_p5 = interference_abs_64qam_epi16(psi_i_m5_p5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m5_p5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_m5_p3, + simde__m128i a_i_m5_p3 = interference_abs_64qam_epi16(psi_i_m5_p3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m5_p3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_m5_p1, + simde__m128i a_i_m5_p1 = interference_abs_64qam_epi16(psi_i_m5_p1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m5_p1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_m5_m1, + simde__m128i a_i_m5_m1 = interference_abs_64qam_epi16(psi_i_m5_m1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m5_m1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_m5_m3, + simde__m128i a_i_m5_m3 = interference_abs_64qam_epi16(psi_i_m5_m3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m5_m3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_m5_m5, + simde__m128i a_i_m5_m5 = interference_abs_64qam_epi16(psi_i_m5_m5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m5_m5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_m5_m7, + simde__m128i a_i_m5_m7 = interference_abs_64qam_epi16(psi_i_m5_m7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m5_m7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_m7_p7, + simde__m128i a_i_m7_p7 = interference_abs_64qam_epi16(psi_i_m7_p7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m7_p7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_m7_p5, + simde__m128i a_i_m7_p5 = interference_abs_64qam_epi16(psi_i_m7_p5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m7_p5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_m7_p3, + simde__m128i a_i_m7_p3 = interference_abs_64qam_epi16(psi_i_m7_p3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m7_p3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_m7_p1, + simde__m128i a_i_m7_p1 = interference_abs_64qam_epi16(psi_i_m7_p1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m7_p1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_m7_m1, + simde__m128i a_i_m7_m1 = interference_abs_64qam_epi16(psi_i_m7_m1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m7_m1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_m7_m3, + simde__m128i a_i_m7_m3 = interference_abs_64qam_epi16(psi_i_m7_m3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m7_m3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_m7_m5, + simde__m128i a_i_m7_m5 = interference_abs_64qam_epi16(psi_i_m7_m5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m7_m5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16(psi_i_m7_m7, + simde__m128i a_i_m7_m7 = interference_abs_64qam_epi16(psi_i_m7_m7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m7_m7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); // Calculation of a group of two terms in the bit metric involving product of psi and interference - prodsum_psi_a_epi16(psi_r_p7_p7, a_r_p7_p7, psi_i_p7_p7, a_i_p7_p7, psi_a_p7_p7); - prodsum_psi_a_epi16(psi_r_p7_p5, a_r_p7_p5, psi_i_p7_p5, a_i_p7_p5, psi_a_p7_p5); - prodsum_psi_a_epi16(psi_r_p7_p3, a_r_p7_p3, psi_i_p7_p3, a_i_p7_p3, psi_a_p7_p3); - prodsum_psi_a_epi16(psi_r_p7_p1, a_r_p7_p1, psi_i_p7_p1, a_i_p7_p1, psi_a_p7_p1); - prodsum_psi_a_epi16(psi_r_p7_m1, a_r_p7_m1, psi_i_p7_m1, a_i_p7_m1, psi_a_p7_m1); - prodsum_psi_a_epi16(psi_r_p7_m3, a_r_p7_m3, psi_i_p7_m3, a_i_p7_m3, psi_a_p7_m3); - prodsum_psi_a_epi16(psi_r_p7_m5, a_r_p7_m5, psi_i_p7_m5, a_i_p7_m5, psi_a_p7_m5); - prodsum_psi_a_epi16(psi_r_p7_m7, a_r_p7_m7, psi_i_p7_m7, a_i_p7_m7, psi_a_p7_m7); - prodsum_psi_a_epi16(psi_r_p5_p7, a_r_p5_p7, psi_i_p5_p7, a_i_p5_p7, psi_a_p5_p7); - prodsum_psi_a_epi16(psi_r_p5_p5, a_r_p5_p5, psi_i_p5_p5, a_i_p5_p5, psi_a_p5_p5); - prodsum_psi_a_epi16(psi_r_p5_p3, a_r_p5_p3, psi_i_p5_p3, a_i_p5_p3, psi_a_p5_p3); - prodsum_psi_a_epi16(psi_r_p5_p1, a_r_p5_p1, psi_i_p5_p1, a_i_p5_p1, psi_a_p5_p1); - prodsum_psi_a_epi16(psi_r_p5_m1, a_r_p5_m1, psi_i_p5_m1, a_i_p5_m1, psi_a_p5_m1); - prodsum_psi_a_epi16(psi_r_p5_m3, a_r_p5_m3, psi_i_p5_m3, a_i_p5_m3, psi_a_p5_m3); - prodsum_psi_a_epi16(psi_r_p5_m5, a_r_p5_m5, psi_i_p5_m5, a_i_p5_m5, psi_a_p5_m5); - prodsum_psi_a_epi16(psi_r_p5_m7, a_r_p5_m7, psi_i_p5_m7, a_i_p5_m7, psi_a_p5_m7); - prodsum_psi_a_epi16(psi_r_p3_p7, a_r_p3_p7, psi_i_p3_p7, a_i_p3_p7, psi_a_p3_p7); - prodsum_psi_a_epi16(psi_r_p3_p5, a_r_p3_p5, psi_i_p3_p5, a_i_p3_p5, psi_a_p3_p5); - prodsum_psi_a_epi16(psi_r_p3_p3, a_r_p3_p3, psi_i_p3_p3, a_i_p3_p3, psi_a_p3_p3); - prodsum_psi_a_epi16(psi_r_p3_p1, a_r_p3_p1, psi_i_p3_p1, a_i_p3_p1, psi_a_p3_p1); - prodsum_psi_a_epi16(psi_r_p3_m1, a_r_p3_m1, psi_i_p3_m1, a_i_p3_m1, psi_a_p3_m1); - prodsum_psi_a_epi16(psi_r_p3_m3, a_r_p3_m3, psi_i_p3_m3, a_i_p3_m3, psi_a_p3_m3); - prodsum_psi_a_epi16(psi_r_p3_m5, a_r_p3_m5, psi_i_p3_m5, a_i_p3_m5, psi_a_p3_m5); - prodsum_psi_a_epi16(psi_r_p3_m7, a_r_p3_m7, psi_i_p3_m7, a_i_p3_m7, psi_a_p3_m7); - prodsum_psi_a_epi16(psi_r_p1_p7, a_r_p1_p7, psi_i_p1_p7, a_i_p1_p7, psi_a_p1_p7); - prodsum_psi_a_epi16(psi_r_p1_p5, a_r_p1_p5, psi_i_p1_p5, a_i_p1_p5, psi_a_p1_p5); - prodsum_psi_a_epi16(psi_r_p1_p3, a_r_p1_p3, psi_i_p1_p3, a_i_p1_p3, psi_a_p1_p3); - prodsum_psi_a_epi16(psi_r_p1_p1, a_r_p1_p1, psi_i_p1_p1, a_i_p1_p1, psi_a_p1_p1); - prodsum_psi_a_epi16(psi_r_p1_m1, a_r_p1_m1, psi_i_p1_m1, a_i_p1_m1, psi_a_p1_m1); - prodsum_psi_a_epi16(psi_r_p1_m3, a_r_p1_m3, psi_i_p1_m3, a_i_p1_m3, psi_a_p1_m3); - prodsum_psi_a_epi16(psi_r_p1_m5, a_r_p1_m5, psi_i_p1_m5, a_i_p1_m5, psi_a_p1_m5); - prodsum_psi_a_epi16(psi_r_p1_m7, a_r_p1_m7, psi_i_p1_m7, a_i_p1_m7, psi_a_p1_m7); - prodsum_psi_a_epi16(psi_r_m1_p7, a_r_m1_p7, psi_i_m1_p7, a_i_m1_p7, psi_a_m1_p7); - prodsum_psi_a_epi16(psi_r_m1_p5, a_r_m1_p5, psi_i_m1_p5, a_i_m1_p5, psi_a_m1_p5); - prodsum_psi_a_epi16(psi_r_m1_p3, a_r_m1_p3, psi_i_m1_p3, a_i_m1_p3, psi_a_m1_p3); - prodsum_psi_a_epi16(psi_r_m1_p1, a_r_m1_p1, psi_i_m1_p1, a_i_m1_p1, psi_a_m1_p1); - prodsum_psi_a_epi16(psi_r_m1_m1, a_r_m1_m1, psi_i_m1_m1, a_i_m1_m1, psi_a_m1_m1); - prodsum_psi_a_epi16(psi_r_m1_m3, a_r_m1_m3, psi_i_m1_m3, a_i_m1_m3, psi_a_m1_m3); - prodsum_psi_a_epi16(psi_r_m1_m5, a_r_m1_m5, psi_i_m1_m5, a_i_m1_m5, psi_a_m1_m5); - prodsum_psi_a_epi16(psi_r_m1_m7, a_r_m1_m7, psi_i_m1_m7, a_i_m1_m7, psi_a_m1_m7); - prodsum_psi_a_epi16(psi_r_m3_p7, a_r_m3_p7, psi_i_m3_p7, a_i_m3_p7, psi_a_m3_p7); - prodsum_psi_a_epi16(psi_r_m3_p5, a_r_m3_p5, psi_i_m3_p5, a_i_m3_p5, psi_a_m3_p5); - prodsum_psi_a_epi16(psi_r_m3_p3, a_r_m3_p3, psi_i_m3_p3, a_i_m3_p3, psi_a_m3_p3); - prodsum_psi_a_epi16(psi_r_m3_p1, a_r_m3_p1, psi_i_m3_p1, a_i_m3_p1, psi_a_m3_p1); - prodsum_psi_a_epi16(psi_r_m3_m1, a_r_m3_m1, psi_i_m3_m1, a_i_m3_m1, psi_a_m3_m1); - prodsum_psi_a_epi16(psi_r_m3_m3, a_r_m3_m3, psi_i_m3_m3, a_i_m3_m3, psi_a_m3_m3); - prodsum_psi_a_epi16(psi_r_m3_m5, a_r_m3_m5, psi_i_m3_m5, a_i_m3_m5, psi_a_m3_m5); - prodsum_psi_a_epi16(psi_r_m3_m7, a_r_m3_m7, psi_i_m3_m7, a_i_m3_m7, psi_a_m3_m7); - prodsum_psi_a_epi16(psi_r_m5_p7, a_r_m5_p7, psi_i_m5_p7, a_i_m5_p7, psi_a_m5_p7); - prodsum_psi_a_epi16(psi_r_m5_p5, a_r_m5_p5, psi_i_m5_p5, a_i_m5_p5, psi_a_m5_p5); - prodsum_psi_a_epi16(psi_r_m5_p3, a_r_m5_p3, psi_i_m5_p3, a_i_m5_p3, psi_a_m5_p3); - prodsum_psi_a_epi16(psi_r_m5_p1, a_r_m5_p1, psi_i_m5_p1, a_i_m5_p1, psi_a_m5_p1); - prodsum_psi_a_epi16(psi_r_m5_m1, a_r_m5_m1, psi_i_m5_m1, a_i_m5_m1, psi_a_m5_m1); - prodsum_psi_a_epi16(psi_r_m5_m3, a_r_m5_m3, psi_i_m5_m3, a_i_m5_m3, psi_a_m5_m3); - prodsum_psi_a_epi16(psi_r_m5_m5, a_r_m5_m5, psi_i_m5_m5, a_i_m5_m5, psi_a_m5_m5); - prodsum_psi_a_epi16(psi_r_m5_m7, a_r_m5_m7, psi_i_m5_m7, a_i_m5_m7, psi_a_m5_m7); - prodsum_psi_a_epi16(psi_r_m7_p7, a_r_m7_p7, psi_i_m7_p7, a_i_m7_p7, psi_a_m7_p7); - prodsum_psi_a_epi16(psi_r_m7_p5, a_r_m7_p5, psi_i_m7_p5, a_i_m7_p5, psi_a_m7_p5); - prodsum_psi_a_epi16(psi_r_m7_p3, a_r_m7_p3, psi_i_m7_p3, a_i_m7_p3, psi_a_m7_p3); - prodsum_psi_a_epi16(psi_r_m7_p1, a_r_m7_p1, psi_i_m7_p1, a_i_m7_p1, psi_a_m7_p1); - prodsum_psi_a_epi16(psi_r_m7_m1, a_r_m7_m1, psi_i_m7_m1, a_i_m7_m1, psi_a_m7_m1); - prodsum_psi_a_epi16(psi_r_m7_m3, a_r_m7_m3, psi_i_m7_m3, a_i_m7_m3, psi_a_m7_m3); - prodsum_psi_a_epi16(psi_r_m7_m5, a_r_m7_m5, psi_i_m7_m5, a_i_m7_m5, psi_a_m7_m5); - prodsum_psi_a_epi16(psi_r_m7_m7, a_r_m7_m7, psi_i_m7_m7, a_i_m7_m7, psi_a_m7_m7); + simde__m128i psi_a_p7_p7 = prodsum_psi_a_epi16(psi_r_p7_p7, a_r_p7_p7, psi_i_p7_p7, a_i_p7_p7); + simde__m128i psi_a_p7_p5 = prodsum_psi_a_epi16(psi_r_p7_p5, a_r_p7_p5, psi_i_p7_p5, a_i_p7_p5); + simde__m128i psi_a_p7_p3 = prodsum_psi_a_epi16(psi_r_p7_p3, a_r_p7_p3, psi_i_p7_p3, a_i_p7_p3); + simde__m128i psi_a_p7_p1 = prodsum_psi_a_epi16(psi_r_p7_p1, a_r_p7_p1, psi_i_p7_p1, a_i_p7_p1); + simde__m128i psi_a_p7_m1 = prodsum_psi_a_epi16(psi_r_p7_m1, a_r_p7_m1, psi_i_p7_m1, a_i_p7_m1); + simde__m128i psi_a_p7_m3 = prodsum_psi_a_epi16(psi_r_p7_m3, a_r_p7_m3, psi_i_p7_m3, a_i_p7_m3); + simde__m128i psi_a_p7_m5 = prodsum_psi_a_epi16(psi_r_p7_m5, a_r_p7_m5, psi_i_p7_m5, a_i_p7_m5); + simde__m128i psi_a_p7_m7 = prodsum_psi_a_epi16(psi_r_p7_m7, a_r_p7_m7, psi_i_p7_m7, a_i_p7_m7); + simde__m128i psi_a_p5_p7 = prodsum_psi_a_epi16(psi_r_p5_p7, a_r_p5_p7, psi_i_p5_p7, a_i_p5_p7); + simde__m128i psi_a_p5_p5 = prodsum_psi_a_epi16(psi_r_p5_p5, a_r_p5_p5, psi_i_p5_p5, a_i_p5_p5); + simde__m128i psi_a_p5_p3 = prodsum_psi_a_epi16(psi_r_p5_p3, a_r_p5_p3, psi_i_p5_p3, a_i_p5_p3); + simde__m128i psi_a_p5_p1 = prodsum_psi_a_epi16(psi_r_p5_p1, a_r_p5_p1, psi_i_p5_p1, a_i_p5_p1); + simde__m128i psi_a_p5_m1 = prodsum_psi_a_epi16(psi_r_p5_m1, a_r_p5_m1, psi_i_p5_m1, a_i_p5_m1); + simde__m128i psi_a_p5_m3 = prodsum_psi_a_epi16(psi_r_p5_m3, a_r_p5_m3, psi_i_p5_m3, a_i_p5_m3); + simde__m128i psi_a_p5_m5 = prodsum_psi_a_epi16(psi_r_p5_m5, a_r_p5_m5, psi_i_p5_m5, a_i_p5_m5); + simde__m128i psi_a_p5_m7 = prodsum_psi_a_epi16(psi_r_p5_m7, a_r_p5_m7, psi_i_p5_m7, a_i_p5_m7); + simde__m128i psi_a_p3_p7 = prodsum_psi_a_epi16(psi_r_p3_p7, a_r_p3_p7, psi_i_p3_p7, a_i_p3_p7); + simde__m128i psi_a_p3_p5 = prodsum_psi_a_epi16(psi_r_p3_p5, a_r_p3_p5, psi_i_p3_p5, a_i_p3_p5); + simde__m128i psi_a_p3_p3 = prodsum_psi_a_epi16(psi_r_p3_p3, a_r_p3_p3, psi_i_p3_p3, a_i_p3_p3); + simde__m128i psi_a_p3_p1 = prodsum_psi_a_epi16(psi_r_p3_p1, a_r_p3_p1, psi_i_p3_p1, a_i_p3_p1); + simde__m128i psi_a_p3_m1 = prodsum_psi_a_epi16(psi_r_p3_m1, a_r_p3_m1, psi_i_p3_m1, a_i_p3_m1); + simde__m128i psi_a_p3_m3 = prodsum_psi_a_epi16(psi_r_p3_m3, a_r_p3_m3, psi_i_p3_m3, a_i_p3_m3); + simde__m128i psi_a_p3_m5 = prodsum_psi_a_epi16(psi_r_p3_m5, a_r_p3_m5, psi_i_p3_m5, a_i_p3_m5); + simde__m128i psi_a_p3_m7 = prodsum_psi_a_epi16(psi_r_p3_m7, a_r_p3_m7, psi_i_p3_m7, a_i_p3_m7); + simde__m128i psi_a_p1_p7 = prodsum_psi_a_epi16(psi_r_p1_p7, a_r_p1_p7, psi_i_p1_p7, a_i_p1_p7); + simde__m128i psi_a_p1_p5 = prodsum_psi_a_epi16(psi_r_p1_p5, a_r_p1_p5, psi_i_p1_p5, a_i_p1_p5); + simde__m128i psi_a_p1_p3 = prodsum_psi_a_epi16(psi_r_p1_p3, a_r_p1_p3, psi_i_p1_p3, a_i_p1_p3); + simde__m128i psi_a_p1_p1 = prodsum_psi_a_epi16(psi_r_p1_p1, a_r_p1_p1, psi_i_p1_p1, a_i_p1_p1); + simde__m128i psi_a_p1_m1 = prodsum_psi_a_epi16(psi_r_p1_m1, a_r_p1_m1, psi_i_p1_m1, a_i_p1_m1); + simde__m128i psi_a_p1_m3 = prodsum_psi_a_epi16(psi_r_p1_m3, a_r_p1_m3, psi_i_p1_m3, a_i_p1_m3); + simde__m128i psi_a_p1_m5 = prodsum_psi_a_epi16(psi_r_p1_m5, a_r_p1_m5, psi_i_p1_m5, a_i_p1_m5); + simde__m128i psi_a_p1_m7 = prodsum_psi_a_epi16(psi_r_p1_m7, a_r_p1_m7, psi_i_p1_m7, a_i_p1_m7); + simde__m128i psi_a_m1_p7 = prodsum_psi_a_epi16(psi_r_m1_p7, a_r_m1_p7, psi_i_m1_p7, a_i_m1_p7); + simde__m128i psi_a_m1_p5 = prodsum_psi_a_epi16(psi_r_m1_p5, a_r_m1_p5, psi_i_m1_p5, a_i_m1_p5); + simde__m128i psi_a_m1_p3 = prodsum_psi_a_epi16(psi_r_m1_p3, a_r_m1_p3, psi_i_m1_p3, a_i_m1_p3); + simde__m128i psi_a_m1_p1 = prodsum_psi_a_epi16(psi_r_m1_p1, a_r_m1_p1, psi_i_m1_p1, a_i_m1_p1); + simde__m128i psi_a_m1_m1 = prodsum_psi_a_epi16(psi_r_m1_m1, a_r_m1_m1, psi_i_m1_m1, a_i_m1_m1); + simde__m128i psi_a_m1_m3 = prodsum_psi_a_epi16(psi_r_m1_m3, a_r_m1_m3, psi_i_m1_m3, a_i_m1_m3); + simde__m128i psi_a_m1_m5 = prodsum_psi_a_epi16(psi_r_m1_m5, a_r_m1_m5, psi_i_m1_m5, a_i_m1_m5); + simde__m128i psi_a_m1_m7 = prodsum_psi_a_epi16(psi_r_m1_m7, a_r_m1_m7, psi_i_m1_m7, a_i_m1_m7); + simde__m128i psi_a_m3_p7 = prodsum_psi_a_epi16(psi_r_m3_p7, a_r_m3_p7, psi_i_m3_p7, a_i_m3_p7); + simde__m128i psi_a_m3_p5 = prodsum_psi_a_epi16(psi_r_m3_p5, a_r_m3_p5, psi_i_m3_p5, a_i_m3_p5); + simde__m128i psi_a_m3_p3 = prodsum_psi_a_epi16(psi_r_m3_p3, a_r_m3_p3, psi_i_m3_p3, a_i_m3_p3); + simde__m128i psi_a_m3_p1 = prodsum_psi_a_epi16(psi_r_m3_p1, a_r_m3_p1, psi_i_m3_p1, a_i_m3_p1); + simde__m128i psi_a_m3_m1 = prodsum_psi_a_epi16(psi_r_m3_m1, a_r_m3_m1, psi_i_m3_m1, a_i_m3_m1); + simde__m128i psi_a_m3_m3 = prodsum_psi_a_epi16(psi_r_m3_m3, a_r_m3_m3, psi_i_m3_m3, a_i_m3_m3); + simde__m128i psi_a_m3_m5 = prodsum_psi_a_epi16(psi_r_m3_m5, a_r_m3_m5, psi_i_m3_m5, a_i_m3_m5); + simde__m128i psi_a_m3_m7 = prodsum_psi_a_epi16(psi_r_m3_m7, a_r_m3_m7, psi_i_m3_m7, a_i_m3_m7); + simde__m128i psi_a_m5_p7 = prodsum_psi_a_epi16(psi_r_m5_p7, a_r_m5_p7, psi_i_m5_p7, a_i_m5_p7); + simde__m128i psi_a_m5_p5 = prodsum_psi_a_epi16(psi_r_m5_p5, a_r_m5_p5, psi_i_m5_p5, a_i_m5_p5); + simde__m128i psi_a_m5_p3 = prodsum_psi_a_epi16(psi_r_m5_p3, a_r_m5_p3, psi_i_m5_p3, a_i_m5_p3); + simde__m128i psi_a_m5_p1 = prodsum_psi_a_epi16(psi_r_m5_p1, a_r_m5_p1, psi_i_m5_p1, a_i_m5_p1); + simde__m128i psi_a_m5_m1 = prodsum_psi_a_epi16(psi_r_m5_m1, a_r_m5_m1, psi_i_m5_m1, a_i_m5_m1); + simde__m128i psi_a_m5_m3 = prodsum_psi_a_epi16(psi_r_m5_m3, a_r_m5_m3, psi_i_m5_m3, a_i_m5_m3); + simde__m128i psi_a_m5_m5 = prodsum_psi_a_epi16(psi_r_m5_m5, a_r_m5_m5, psi_i_m5_m5, a_i_m5_m5); + simde__m128i psi_a_m5_m7 = prodsum_psi_a_epi16(psi_r_m5_m7, a_r_m5_m7, psi_i_m5_m7, a_i_m5_m7); + simde__m128i psi_a_m7_p7 = prodsum_psi_a_epi16(psi_r_m7_p7, a_r_m7_p7, psi_i_m7_p7, a_i_m7_p7); + simde__m128i psi_a_m7_p5 = prodsum_psi_a_epi16(psi_r_m7_p5, a_r_m7_p5, psi_i_m7_p5, a_i_m7_p5); + simde__m128i psi_a_m7_p3 = prodsum_psi_a_epi16(psi_r_m7_p3, a_r_m7_p3, psi_i_m7_p3, a_i_m7_p3); + simde__m128i psi_a_m7_p1 = prodsum_psi_a_epi16(psi_r_m7_p1, a_r_m7_p1, psi_i_m7_p1, a_i_m7_p1); + simde__m128i psi_a_m7_m1 = prodsum_psi_a_epi16(psi_r_m7_m1, a_r_m7_m1, psi_i_m7_m1, a_i_m7_m1); + simde__m128i psi_a_m7_m3 = prodsum_psi_a_epi16(psi_r_m7_m3, a_r_m7_m3, psi_i_m7_m3, a_i_m7_m3); + simde__m128i psi_a_m7_m5 = prodsum_psi_a_epi16(psi_r_m7_m5, a_r_m7_m5, psi_i_m7_m5, a_i_m7_m5); + simde__m128i psi_a_m7_m7 = prodsum_psi_a_epi16(psi_r_m7_m7, a_r_m7_m7, psi_i_m7_m7, a_i_m7_m7); // Multiply by sqrt(2) psi_a_p7_p7 = simde_mm_mulhi_epi16(psi_a_p7_p7, ONE_OVER_SQRT_2); @@ -3684,70 +3576,70 @@ void nr_ulsch_qam64_qam64(c16_t *stream0_in, psi_a_m7_m7 = simde_mm_slli_epi16(psi_a_m7_m7, 2); // Calculation of a group of two terms in the bit metric involving squares of interference - square_a_64qam_epi16(a_r_p7_p7, a_i_p7_p7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p7_p7); - square_a_64qam_epi16(a_r_p7_p5, a_i_p7_p5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p7_p5); - square_a_64qam_epi16(a_r_p7_p3, a_i_p7_p3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p7_p3); - square_a_64qam_epi16(a_r_p7_p1, a_i_p7_p1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p7_p1); - square_a_64qam_epi16(a_r_p7_m1, a_i_p7_m1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p7_m1); - square_a_64qam_epi16(a_r_p7_m3, a_i_p7_m3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p7_m3); - square_a_64qam_epi16(a_r_p7_m5, a_i_p7_m5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p7_m5); - square_a_64qam_epi16(a_r_p7_m7, a_i_p7_m7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p7_m7); - square_a_64qam_epi16(a_r_p5_p7, a_i_p5_p7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p5_p7); - square_a_64qam_epi16(a_r_p5_p5, a_i_p5_p5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p5_p5); - square_a_64qam_epi16(a_r_p5_p3, a_i_p5_p3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p5_p3); - square_a_64qam_epi16(a_r_p5_p1, a_i_p5_p1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p5_p1); - square_a_64qam_epi16(a_r_p5_m1, a_i_p5_m1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p5_m1); - square_a_64qam_epi16(a_r_p5_m3, a_i_p5_m3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p5_m3); - square_a_64qam_epi16(a_r_p5_m5, a_i_p5_m5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p5_m5); - square_a_64qam_epi16(a_r_p5_m7, a_i_p5_m7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p5_m7); - square_a_64qam_epi16(a_r_p3_p7, a_i_p3_p7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p3_p7); - square_a_64qam_epi16(a_r_p3_p5, a_i_p3_p5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p3_p5); - square_a_64qam_epi16(a_r_p3_p3, a_i_p3_p3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p3_p3); - square_a_64qam_epi16(a_r_p3_p1, a_i_p3_p1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p3_p1); - square_a_64qam_epi16(a_r_p3_m1, a_i_p3_m1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p3_m1); - square_a_64qam_epi16(a_r_p3_m3, a_i_p3_m3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p3_m3); - square_a_64qam_epi16(a_r_p3_m5, a_i_p3_m5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p3_m5); - square_a_64qam_epi16(a_r_p3_m7, a_i_p3_m7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p3_m7); - square_a_64qam_epi16(a_r_p1_p7, a_i_p1_p7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p1_p7); - square_a_64qam_epi16(a_r_p1_p5, a_i_p1_p5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p1_p5); - square_a_64qam_epi16(a_r_p1_p3, a_i_p1_p3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p1_p3); - square_a_64qam_epi16(a_r_p1_p1, a_i_p1_p1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p1_p1); - square_a_64qam_epi16(a_r_p1_m1, a_i_p1_m1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p1_m1); - square_a_64qam_epi16(a_r_p1_m3, a_i_p1_m3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p1_m3); - square_a_64qam_epi16(a_r_p1_m5, a_i_p1_m5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p1_m5); - square_a_64qam_epi16(a_r_p1_m7, a_i_p1_m7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p1_m7); - square_a_64qam_epi16(a_r_m1_p7, a_i_m1_p7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m1_p7); - square_a_64qam_epi16(a_r_m1_p5, a_i_m1_p5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m1_p5); - square_a_64qam_epi16(a_r_m1_p3, a_i_m1_p3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m1_p3); - square_a_64qam_epi16(a_r_m1_p1, a_i_m1_p1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m1_p1); - square_a_64qam_epi16(a_r_m1_m1, a_i_m1_m1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m1_m1); - square_a_64qam_epi16(a_r_m1_m3, a_i_m1_m3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m1_m3); - square_a_64qam_epi16(a_r_m1_m5, a_i_m1_m5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m1_m5); - square_a_64qam_epi16(a_r_m1_m7, a_i_m1_m7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m1_m7); - square_a_64qam_epi16(a_r_m3_p7, a_i_m3_p7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m3_p7); - square_a_64qam_epi16(a_r_m3_p5, a_i_m3_p5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m3_p5); - square_a_64qam_epi16(a_r_m3_p3, a_i_m3_p3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m3_p3); - square_a_64qam_epi16(a_r_m3_p1, a_i_m3_p1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m3_p1); - square_a_64qam_epi16(a_r_m3_m1, a_i_m3_m1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m3_m1); - square_a_64qam_epi16(a_r_m3_m3, a_i_m3_m3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m3_m3); - square_a_64qam_epi16(a_r_m3_m5, a_i_m3_m5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m3_m5); - square_a_64qam_epi16(a_r_m3_m7, a_i_m3_m7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m3_m7); - square_a_64qam_epi16(a_r_m5_p7, a_i_m5_p7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m5_p7); - square_a_64qam_epi16(a_r_m5_p5, a_i_m5_p5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m5_p5); - square_a_64qam_epi16(a_r_m5_p3, a_i_m5_p3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m5_p3); - square_a_64qam_epi16(a_r_m5_p1, a_i_m5_p1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m5_p1); - square_a_64qam_epi16(a_r_m5_m1, a_i_m5_m1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m5_m1); - square_a_64qam_epi16(a_r_m5_m3, a_i_m5_m3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m5_m3); - square_a_64qam_epi16(a_r_m5_m5, a_i_m5_m5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m5_m5); - square_a_64qam_epi16(a_r_m5_m7, a_i_m5_m7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m5_m7); - square_a_64qam_epi16(a_r_m7_p7, a_i_m7_p7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m7_p7); - square_a_64qam_epi16(a_r_m7_p5, a_i_m7_p5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m7_p5); - square_a_64qam_epi16(a_r_m7_p3, a_i_m7_p3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m7_p3); - square_a_64qam_epi16(a_r_m7_p1, a_i_m7_p1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m7_p1); - square_a_64qam_epi16(a_r_m7_m1, a_i_m7_m1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m7_m1); - square_a_64qam_epi16(a_r_m7_m3, a_i_m7_m3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m7_m3); - square_a_64qam_epi16(a_r_m7_m5, a_i_m7_m5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m7_m5); - square_a_64qam_epi16(a_r_m7_m7, a_i_m7_m7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m7_m7); + simde__m128i a_sq_p7_p7 = square_a_64qam_epi16(a_r_p7_p7, a_i_p7_p7, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_p7_p5 = square_a_64qam_epi16(a_r_p7_p5, a_i_p7_p5, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_p7_p3 = square_a_64qam_epi16(a_r_p7_p3, a_i_p7_p3, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_p7_p1 = square_a_64qam_epi16(a_r_p7_p1, a_i_p7_p1, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_p7_m1 = square_a_64qam_epi16(a_r_p7_m1, a_i_p7_m1, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_p7_m3 = square_a_64qam_epi16(a_r_p7_m3, a_i_p7_m3, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_p7_m5 = square_a_64qam_epi16(a_r_p7_m5, a_i_p7_m5, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_p7_m7 = square_a_64qam_epi16(a_r_p7_m7, a_i_p7_m7, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_p5_p7 = square_a_64qam_epi16(a_r_p5_p7, a_i_p5_p7, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_p5_p5 = square_a_64qam_epi16(a_r_p5_p5, a_i_p5_p5, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_p5_p3 = square_a_64qam_epi16(a_r_p5_p3, a_i_p5_p3, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_p5_p1 = square_a_64qam_epi16(a_r_p5_p1, a_i_p5_p1, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_p5_m1 = square_a_64qam_epi16(a_r_p5_m1, a_i_p5_m1, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_p5_m3 = square_a_64qam_epi16(a_r_p5_m3, a_i_p5_m3, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_p5_m5 = square_a_64qam_epi16(a_r_p5_m5, a_i_p5_m5, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_p5_m7 = square_a_64qam_epi16(a_r_p5_m7, a_i_p5_m7, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_p3_p7 = square_a_64qam_epi16(a_r_p3_p7, a_i_p3_p7, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_p3_p5 = square_a_64qam_epi16(a_r_p3_p5, a_i_p3_p5, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_p3_p3 = square_a_64qam_epi16(a_r_p3_p3, a_i_p3_p3, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_p3_p1 = square_a_64qam_epi16(a_r_p3_p1, a_i_p3_p1, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_p3_m1 = square_a_64qam_epi16(a_r_p3_m1, a_i_p3_m1, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_p3_m3 = square_a_64qam_epi16(a_r_p3_m3, a_i_p3_m3, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_p3_m5 = square_a_64qam_epi16(a_r_p3_m5, a_i_p3_m5, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_p3_m7 = square_a_64qam_epi16(a_r_p3_m7, a_i_p3_m7, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_p1_p7 = square_a_64qam_epi16(a_r_p1_p7, a_i_p1_p7, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_p1_p5 = square_a_64qam_epi16(a_r_p1_p5, a_i_p1_p5, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_p1_p3 = square_a_64qam_epi16(a_r_p1_p3, a_i_p1_p3, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_p1_p1 = square_a_64qam_epi16(a_r_p1_p1, a_i_p1_p1, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_p1_m1 = square_a_64qam_epi16(a_r_p1_m1, a_i_p1_m1, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_p1_m3 = square_a_64qam_epi16(a_r_p1_m3, a_i_p1_m3, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_p1_m5 = square_a_64qam_epi16(a_r_p1_m5, a_i_p1_m5, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_p1_m7 = square_a_64qam_epi16(a_r_p1_m7, a_i_p1_m7, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_m1_p7 = square_a_64qam_epi16(a_r_m1_p7, a_i_m1_p7, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_m1_p5 = square_a_64qam_epi16(a_r_m1_p5, a_i_m1_p5, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_m1_p3 = square_a_64qam_epi16(a_r_m1_p3, a_i_m1_p3, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_m1_p1 = square_a_64qam_epi16(a_r_m1_p1, a_i_m1_p1, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_m1_m1 = square_a_64qam_epi16(a_r_m1_m1, a_i_m1_m1, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_m1_m3 = square_a_64qam_epi16(a_r_m1_m3, a_i_m1_m3, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_m1_m5 = square_a_64qam_epi16(a_r_m1_m5, a_i_m1_m5, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_m1_m7 = square_a_64qam_epi16(a_r_m1_m7, a_i_m1_m7, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_m3_p7 = square_a_64qam_epi16(a_r_m3_p7, a_i_m3_p7, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_m3_p5 = square_a_64qam_epi16(a_r_m3_p5, a_i_m3_p5, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_m3_p3 = square_a_64qam_epi16(a_r_m3_p3, a_i_m3_p3, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_m3_p1 = square_a_64qam_epi16(a_r_m3_p1, a_i_m3_p1, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_m3_m1 = square_a_64qam_epi16(a_r_m3_m1, a_i_m3_m1, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_m3_m3 = square_a_64qam_epi16(a_r_m3_m3, a_i_m3_m3, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_m3_m5 = square_a_64qam_epi16(a_r_m3_m5, a_i_m3_m5, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_m3_m7 = square_a_64qam_epi16(a_r_m3_m7, a_i_m3_m7, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_m5_p7 = square_a_64qam_epi16(a_r_m5_p7, a_i_m5_p7, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_m5_p5 = square_a_64qam_epi16(a_r_m5_p5, a_i_m5_p5, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_m5_p3 = square_a_64qam_epi16(a_r_m5_p3, a_i_m5_p3, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_m5_p1 = square_a_64qam_epi16(a_r_m5_p1, a_i_m5_p1, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_m5_m1 = square_a_64qam_epi16(a_r_m5_m1, a_i_m5_m1, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_m5_m3 = square_a_64qam_epi16(a_r_m5_m3, a_i_m5_m3, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_m5_m5 = square_a_64qam_epi16(a_r_m5_m5, a_i_m5_m5, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_m5_m7 = square_a_64qam_epi16(a_r_m5_m7, a_i_m5_m7, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_m7_p7 = square_a_64qam_epi16(a_r_m7_p7, a_i_m7_p7, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_m7_p5 = square_a_64qam_epi16(a_r_m7_p5, a_i_m7_p5, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_m7_p3 = square_a_64qam_epi16(a_r_m7_p3, a_i_m7_p3, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_m7_p1 = square_a_64qam_epi16(a_r_m7_p1, a_i_m7_p1, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_m7_m1 = square_a_64qam_epi16(a_r_m7_m1, a_i_m7_m1, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_m7_m3 = square_a_64qam_epi16(a_r_m7_m3, a_i_m7_m3, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_m7_m5 = square_a_64qam_epi16(a_r_m7_m5, a_i_m7_m5, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m128i a_sq_m7_m7 = square_a_64qam_epi16(a_r_m7_m7, a_i_m7_m7, ch_mag_int, SQRT_42_OVER_FOUR); // Computing different multiples of ||h0||^2 // x=1, y=1 @@ -4844,1225 +4736,1097 @@ void nr_ulsch_qam64_qam64(c16_t *stream0_in, two_ch_mag_int_with_sigma2 = ch_mag_int; // *4 three_ch_mag_int_with_sigma2 = simde_mm256_adds_epi16(ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2); // *6 simde__m256i tmp_result, tmp_result2, tmp_result3, tmp_result4; - interference_abs_64qam_epi16_256(psi_r_p7_p7, + simde__m256i a_r_p7_p7 = interference_abs_64qam_epi16_256(psi_r_p7_p7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p7_p7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_p7_p5, + simde__m256i a_r_p7_p5 = interference_abs_64qam_epi16_256(psi_r_p7_p5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p7_p5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_p7_p3, + simde__m256i a_r_p7_p3 = interference_abs_64qam_epi16_256(psi_r_p7_p3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p7_p3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_p7_p1, + simde__m256i a_r_p7_p1 = interference_abs_64qam_epi16_256(psi_r_p7_p1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p7_p1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_p7_m1, + simde__m256i a_r_p7_m1 = interference_abs_64qam_epi16_256(psi_r_p7_m1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p7_m1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_p7_m3, + simde__m256i a_r_p7_m3 = interference_abs_64qam_epi16_256(psi_r_p7_m3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p7_m3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_p7_m5, + simde__m256i a_r_p7_m5 = interference_abs_64qam_epi16_256(psi_r_p7_m5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p7_m5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_p7_m7, + simde__m256i a_r_p7_m7 = interference_abs_64qam_epi16_256(psi_r_p7_m7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p7_m7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_p5_p7, + simde__m256i a_r_p5_p7 = interference_abs_64qam_epi16_256(psi_r_p5_p7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p5_p7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_p5_p5, + simde__m256i a_r_p5_p5 = interference_abs_64qam_epi16_256(psi_r_p5_p5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p5_p5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_p5_p3, + simde__m256i a_r_p5_p3 = interference_abs_64qam_epi16_256(psi_r_p5_p3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p5_p3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_p5_p1, + simde__m256i a_r_p5_p1 = interference_abs_64qam_epi16_256(psi_r_p5_p1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p5_p1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_p5_m1, + simde__m256i a_r_p5_m1 = interference_abs_64qam_epi16_256(psi_r_p5_m1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p5_m1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_p5_m3, + simde__m256i a_r_p5_m3 = interference_abs_64qam_epi16_256(psi_r_p5_m3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p5_m3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_p5_m5, + simde__m256i a_r_p5_m5 = interference_abs_64qam_epi16_256(psi_r_p5_m5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p5_m5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_p5_m7, + simde__m256i a_r_p5_m7 = interference_abs_64qam_epi16_256(psi_r_p5_m7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p5_m7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_p3_p7, + simde__m256i a_r_p3_p7 = interference_abs_64qam_epi16_256(psi_r_p3_p7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p3_p7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_p3_p5, + simde__m256i a_r_p3_p5 = interference_abs_64qam_epi16_256(psi_r_p3_p5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p3_p5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_p3_p3, + simde__m256i a_r_p3_p3 = interference_abs_64qam_epi16_256(psi_r_p3_p3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p3_p3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_p3_p1, + simde__m256i a_r_p3_p1 = interference_abs_64qam_epi16_256(psi_r_p3_p1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p3_p1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_p3_m1, + simde__m256i a_r_p3_m1 = interference_abs_64qam_epi16_256(psi_r_p3_m1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p3_m1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_p3_m3, + simde__m256i a_r_p3_m3 = interference_abs_64qam_epi16_256(psi_r_p3_m3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p3_m3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_p3_m5, + simde__m256i a_r_p3_m5 = interference_abs_64qam_epi16_256(psi_r_p3_m5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p3_m5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_p3_m7, + simde__m256i a_r_p3_m7 = interference_abs_64qam_epi16_256(psi_r_p3_m7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p3_m7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_p1_p7, + simde__m256i a_r_p1_p7 = interference_abs_64qam_epi16_256(psi_r_p1_p7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p1_p7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_p1_p5, + simde__m256i a_r_p1_p5 = interference_abs_64qam_epi16_256(psi_r_p1_p5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p1_p5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_p1_p3, + simde__m256i a_r_p1_p3 = interference_abs_64qam_epi16_256(psi_r_p1_p3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p1_p3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_p1_p1, + simde__m256i a_r_p1_p1 = interference_abs_64qam_epi16_256(psi_r_p1_p1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p1_p1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_p1_m1, + simde__m256i a_r_p1_m1 = interference_abs_64qam_epi16_256(psi_r_p1_m1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p1_m1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_p1_m3, + simde__m256i a_r_p1_m3 = interference_abs_64qam_epi16_256(psi_r_p1_m3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p1_m3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_p1_m5, + simde__m256i a_r_p1_m5 = interference_abs_64qam_epi16_256(psi_r_p1_m5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p1_m5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_p1_m7, + simde__m256i a_r_p1_m7 = interference_abs_64qam_epi16_256(psi_r_p1_m7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_p1_m7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_m1_p7, + simde__m256i a_r_m1_p7 = interference_abs_64qam_epi16_256(psi_r_m1_p7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m1_p7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_m1_p5, + simde__m256i a_r_m1_p5 = interference_abs_64qam_epi16_256(psi_r_m1_p5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m1_p5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_m1_p3, + simde__m256i a_r_m1_p3 = interference_abs_64qam_epi16_256(psi_r_m1_p3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m1_p3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_m1_p1, + simde__m256i a_r_m1_p1 = interference_abs_64qam_epi16_256(psi_r_m1_p1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m1_p1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_m1_m1, + simde__m256i a_r_m1_m1 = interference_abs_64qam_epi16_256(psi_r_m1_m1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m1_m1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_m1_m3, + simde__m256i a_r_m1_m3 = interference_abs_64qam_epi16_256(psi_r_m1_m3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m1_m3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_m1_m5, + simde__m256i a_r_m1_m5 = interference_abs_64qam_epi16_256(psi_r_m1_m5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m1_m5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_m1_m7, + simde__m256i a_r_m1_m7 = interference_abs_64qam_epi16_256(psi_r_m1_m7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m1_m7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_m3_p7, + simde__m256i a_r_m3_p7 = interference_abs_64qam_epi16_256(psi_r_m3_p7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m3_p7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_m3_p5, + simde__m256i a_r_m3_p5 = interference_abs_64qam_epi16_256(psi_r_m3_p5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m3_p5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_m3_p3, + simde__m256i a_r_m3_p3 = interference_abs_64qam_epi16_256(psi_r_m3_p3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m3_p3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_m3_p1, + simde__m256i a_r_m3_p1 = interference_abs_64qam_epi16_256(psi_r_m3_p1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m3_p1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_m3_m1, + simde__m256i a_r_m3_m1 = interference_abs_64qam_epi16_256(psi_r_m3_m1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m3_m1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_m3_m3, + simde__m256i a_r_m3_m3 = interference_abs_64qam_epi16_256(psi_r_m3_m3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m3_m3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_m3_m5, + simde__m256i a_r_m3_m5 = interference_abs_64qam_epi16_256(psi_r_m3_m5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m3_m5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_m3_m7, + simde__m256i a_r_m3_m7 = interference_abs_64qam_epi16_256(psi_r_m3_m7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m3_m7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_m5_p7, + simde__m256i a_r_m5_p7 = interference_abs_64qam_epi16_256(psi_r_m5_p7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m5_p7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_m5_p5, + simde__m256i a_r_m5_p5 = interference_abs_64qam_epi16_256(psi_r_m5_p5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m5_p5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_m5_p3, + simde__m256i a_r_m5_p3 = interference_abs_64qam_epi16_256(psi_r_m5_p3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m5_p3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_m5_p1, + simde__m256i a_r_m5_p1 = interference_abs_64qam_epi16_256(psi_r_m5_p1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m5_p1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_m5_m1, + simde__m256i a_r_m5_m1 = interference_abs_64qam_epi16_256(psi_r_m5_m1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m5_m1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_m5_m3, + simde__m256i a_r_m5_m3 = interference_abs_64qam_epi16_256(psi_r_m5_m3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m5_m3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_m5_m5, + simde__m256i a_r_m5_m5 = interference_abs_64qam_epi16_256(psi_r_m5_m5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m5_m5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_m5_m7, + simde__m256i a_r_m5_m7 = interference_abs_64qam_epi16_256(psi_r_m5_m7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m5_m7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_m7_p7, + simde__m256i a_r_m7_p7 = interference_abs_64qam_epi16_256(psi_r_m7_p7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m7_p7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_m7_p5, + simde__m256i a_r_m7_p5 = interference_abs_64qam_epi16_256(psi_r_m7_p5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m7_p5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_m7_p3, + simde__m256i a_r_m7_p3 = interference_abs_64qam_epi16_256(psi_r_m7_p3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m7_p3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_m7_p1, + simde__m256i a_r_m7_p1 = interference_abs_64qam_epi16_256(psi_r_m7_p1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m7_p1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_m7_m1, + simde__m256i a_r_m7_m1 = interference_abs_64qam_epi16_256(psi_r_m7_m1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m7_m1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_m7_m3, + simde__m256i a_r_m7_m3 = interference_abs_64qam_epi16_256(psi_r_m7_m3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m7_m3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_m7_m5, + simde__m256i a_r_m7_m5 = interference_abs_64qam_epi16_256(psi_r_m7_m5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m7_m5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_r_m7_m7, + simde__m256i a_r_m7_m7 = interference_abs_64qam_epi16_256(psi_r_m7_m7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_r_m7_m7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_p7_p7, + simde__m256i a_i_p7_p7 = interference_abs_64qam_epi16_256(psi_i_p7_p7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p7_p7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_p7_p5, + simde__m256i a_i_p7_p5 = interference_abs_64qam_epi16_256(psi_i_p7_p5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p7_p5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_p7_p3, + simde__m256i a_i_p7_p3 = interference_abs_64qam_epi16_256(psi_i_p7_p3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p7_p3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_p7_p1, + simde__m256i a_i_p7_p1 = interference_abs_64qam_epi16_256(psi_i_p7_p1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p7_p1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_p7_m1, + simde__m256i a_i_p7_m1 = interference_abs_64qam_epi16_256(psi_i_p7_m1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p7_m1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_p7_m3, + simde__m256i a_i_p7_m3 = interference_abs_64qam_epi16_256(psi_i_p7_m3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p7_m3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_p7_m5, + simde__m256i a_i_p7_m5 = interference_abs_64qam_epi16_256(psi_i_p7_m5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p7_m5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_p7_m7, + simde__m256i a_i_p7_m7 = interference_abs_64qam_epi16_256(psi_i_p7_m7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p7_m7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_p5_p7, + simde__m256i a_i_p5_p7 = interference_abs_64qam_epi16_256(psi_i_p5_p7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p5_p7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_p5_p5, + simde__m256i a_i_p5_p5 = interference_abs_64qam_epi16_256(psi_i_p5_p5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p5_p5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_p5_p3, + simde__m256i a_i_p5_p3 = interference_abs_64qam_epi16_256(psi_i_p5_p3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p5_p3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_p5_p1, + simde__m256i a_i_p5_p1 = interference_abs_64qam_epi16_256(psi_i_p5_p1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p5_p1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_p5_m1, + simde__m256i a_i_p5_m1 = interference_abs_64qam_epi16_256(psi_i_p5_m1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p5_m1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_p5_m3, + simde__m256i a_i_p5_m3 = interference_abs_64qam_epi16_256(psi_i_p5_m3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p5_m3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_p5_m5, + simde__m256i a_i_p5_m5 = interference_abs_64qam_epi16_256(psi_i_p5_m5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p5_m5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_p5_m7, + simde__m256i a_i_p5_m7 = interference_abs_64qam_epi16_256(psi_i_p5_m7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p5_m7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_p3_p7, + simde__m256i a_i_p3_p7 = interference_abs_64qam_epi16_256(psi_i_p3_p7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p3_p7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_p3_p5, + simde__m256i a_i_p3_p5 = interference_abs_64qam_epi16_256(psi_i_p3_p5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p3_p5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_p3_p3, + simde__m256i a_i_p3_p3 = interference_abs_64qam_epi16_256(psi_i_p3_p3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p3_p3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_p3_p1, + simde__m256i a_i_p3_p1 = interference_abs_64qam_epi16_256(psi_i_p3_p1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p3_p1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_p3_m1, + simde__m256i a_i_p3_m1 = interference_abs_64qam_epi16_256(psi_i_p3_m1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p3_m1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_p3_m3, + simde__m256i a_i_p3_m3 = interference_abs_64qam_epi16_256(psi_i_p3_m3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p3_m3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_p3_m5, + simde__m256i a_i_p3_m5 = interference_abs_64qam_epi16_256(psi_i_p3_m5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p3_m5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_p3_m7, + simde__m256i a_i_p3_m7 = interference_abs_64qam_epi16_256(psi_i_p3_m7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p3_m7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_p1_p7, + simde__m256i a_i_p1_p7 = interference_abs_64qam_epi16_256(psi_i_p1_p7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p1_p7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_p1_p5, + simde__m256i a_i_p1_p5 = interference_abs_64qam_epi16_256(psi_i_p1_p5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p1_p5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_p1_p3, + simde__m256i a_i_p1_p3 = interference_abs_64qam_epi16_256(psi_i_p1_p3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p1_p3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_p1_p1, + simde__m256i a_i_p1_p1 = interference_abs_64qam_epi16_256(psi_i_p1_p1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p1_p1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_p1_m1, + simde__m256i a_i_p1_m1 = interference_abs_64qam_epi16_256(psi_i_p1_m1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p1_m1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_p1_m3, + simde__m256i a_i_p1_m3 = interference_abs_64qam_epi16_256(psi_i_p1_m3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p1_m3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_p1_m5, + simde__m256i a_i_p1_m5 = interference_abs_64qam_epi16_256(psi_i_p1_m5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p1_m5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_p1_m7, + simde__m256i a_i_p1_m7 = interference_abs_64qam_epi16_256(psi_i_p1_m7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_p1_m7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_m1_p7, + simde__m256i a_i_m1_p7 = interference_abs_64qam_epi16_256(psi_i_m1_p7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m1_p7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_m1_p5, + simde__m256i a_i_m1_p5 = interference_abs_64qam_epi16_256(psi_i_m1_p5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m1_p5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_m1_p3, + simde__m256i a_i_m1_p3 = interference_abs_64qam_epi16_256(psi_i_m1_p3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m1_p3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_m1_p1, + simde__m256i a_i_m1_p1 = interference_abs_64qam_epi16_256(psi_i_m1_p1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m1_p1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_m1_m1, + simde__m256i a_i_m1_m1 = interference_abs_64qam_epi16_256(psi_i_m1_m1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m1_m1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_m1_m3, + simde__m256i a_i_m1_m3 = interference_abs_64qam_epi16_256(psi_i_m1_m3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m1_m3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_m1_m5, + simde__m256i a_i_m1_m5 = interference_abs_64qam_epi16_256(psi_i_m1_m5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m1_m5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_m1_m7, + simde__m256i a_i_m1_m7 = interference_abs_64qam_epi16_256(psi_i_m1_m7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m1_m7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_m3_p7, + simde__m256i a_i_m3_p7 = interference_abs_64qam_epi16_256(psi_i_m3_p7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m3_p7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_m3_p5, + simde__m256i a_i_m3_p5 = interference_abs_64qam_epi16_256(psi_i_m3_p5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m3_p5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_m3_p3, + simde__m256i a_i_m3_p3 = interference_abs_64qam_epi16_256(psi_i_m3_p3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m3_p3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_m3_p1, + simde__m256i a_i_m3_p1 = interference_abs_64qam_epi16_256(psi_i_m3_p1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m3_p1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_m3_m1, + simde__m256i a_i_m3_m1 = interference_abs_64qam_epi16_256(psi_i_m3_m1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m3_m1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_m3_m3, + simde__m256i a_i_m3_m3 = interference_abs_64qam_epi16_256(psi_i_m3_m3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m3_m3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_m3_m5, + simde__m256i a_i_m3_m5 = interference_abs_64qam_epi16_256(psi_i_m3_m5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m3_m5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_m3_m7, + simde__m256i a_i_m3_m7 = interference_abs_64qam_epi16_256(psi_i_m3_m7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m3_m7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_m5_p7, + simde__m256i a_i_m5_p7 = interference_abs_64qam_epi16_256(psi_i_m5_p7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m5_p7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_m5_p5, + simde__m256i a_i_m5_p5 = interference_abs_64qam_epi16_256(psi_i_m5_p5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m5_p5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_m5_p3, + simde__m256i a_i_m5_p3 = interference_abs_64qam_epi16_256(psi_i_m5_p3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m5_p3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_m5_p1, + simde__m256i a_i_m5_p1 = interference_abs_64qam_epi16_256(psi_i_m5_p1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m5_p1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_m5_m1, + simde__m256i a_i_m5_m1 = interference_abs_64qam_epi16_256(psi_i_m5_m1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m5_m1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_m5_m3, + simde__m256i a_i_m5_m3 = interference_abs_64qam_epi16_256(psi_i_m5_m3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m5_m3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_m5_m5, + simde__m256i a_i_m5_m5 = interference_abs_64qam_epi16_256(psi_i_m5_m5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m5_m5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_m5_m7, + simde__m256i a_i_m5_m7 = interference_abs_64qam_epi16_256(psi_i_m5_m7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m5_m7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_m7_p7, + simde__m256i a_i_m7_p7 = interference_abs_64qam_epi16_256(psi_i_m7_p7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m7_p7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_m7_p5, + simde__m256i a_i_m7_p5 = interference_abs_64qam_epi16_256(psi_i_m7_p5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m7_p5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_m7_p3, + simde__m256i a_i_m7_p3 = interference_abs_64qam_epi16_256(psi_i_m7_p3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m7_p3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_m7_p1, + simde__m256i a_i_m7_p1 = interference_abs_64qam_epi16_256(psi_i_m7_p1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m7_p1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_m7_m1, + simde__m256i a_i_m7_m1 = interference_abs_64qam_epi16_256(psi_i_m7_m1, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m7_m1, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_m7_m3, + simde__m256i a_i_m7_m3 = interference_abs_64qam_epi16_256(psi_i_m7_m3, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m7_m3, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_m7_m5, + simde__m256i a_i_m7_m5 = interference_abs_64qam_epi16_256(psi_i_m7_m5, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m7_m5, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); - interference_abs_64qam_epi16_256(psi_i_m7_m7, + simde__m256i a_i_m7_m7 = interference_abs_64qam_epi16_256(psi_i_m7_m7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, - a_i_m7_m7, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); // Calculation of a group of two terms in the bit metric involving product of psi and interference - prodsum_psi_a_epi16_256(psi_r_p7_p7, a_r_p7_p7, psi_i_p7_p7, a_i_p7_p7, psi_a_p7_p7); - prodsum_psi_a_epi16_256(psi_r_p7_p5, a_r_p7_p5, psi_i_p7_p5, a_i_p7_p5, psi_a_p7_p5); - prodsum_psi_a_epi16_256(psi_r_p7_p3, a_r_p7_p3, psi_i_p7_p3, a_i_p7_p3, psi_a_p7_p3); - prodsum_psi_a_epi16_256(psi_r_p7_p1, a_r_p7_p1, psi_i_p7_p1, a_i_p7_p1, psi_a_p7_p1); - prodsum_psi_a_epi16_256(psi_r_p7_m1, a_r_p7_m1, psi_i_p7_m1, a_i_p7_m1, psi_a_p7_m1); - prodsum_psi_a_epi16_256(psi_r_p7_m3, a_r_p7_m3, psi_i_p7_m3, a_i_p7_m3, psi_a_p7_m3); - prodsum_psi_a_epi16_256(psi_r_p7_m5, a_r_p7_m5, psi_i_p7_m5, a_i_p7_m5, psi_a_p7_m5); - prodsum_psi_a_epi16_256(psi_r_p7_m7, a_r_p7_m7, psi_i_p7_m7, a_i_p7_m7, psi_a_p7_m7); - prodsum_psi_a_epi16_256(psi_r_p5_p7, a_r_p5_p7, psi_i_p5_p7, a_i_p5_p7, psi_a_p5_p7); - prodsum_psi_a_epi16_256(psi_r_p5_p5, a_r_p5_p5, psi_i_p5_p5, a_i_p5_p5, psi_a_p5_p5); - prodsum_psi_a_epi16_256(psi_r_p5_p3, a_r_p5_p3, psi_i_p5_p3, a_i_p5_p3, psi_a_p5_p3); - prodsum_psi_a_epi16_256(psi_r_p5_p1, a_r_p5_p1, psi_i_p5_p1, a_i_p5_p1, psi_a_p5_p1); - prodsum_psi_a_epi16_256(psi_r_p5_m1, a_r_p5_m1, psi_i_p5_m1, a_i_p5_m1, psi_a_p5_m1); - prodsum_psi_a_epi16_256(psi_r_p5_m3, a_r_p5_m3, psi_i_p5_m3, a_i_p5_m3, psi_a_p5_m3); - prodsum_psi_a_epi16_256(psi_r_p5_m5, a_r_p5_m5, psi_i_p5_m5, a_i_p5_m5, psi_a_p5_m5); - prodsum_psi_a_epi16_256(psi_r_p5_m7, a_r_p5_m7, psi_i_p5_m7, a_i_p5_m7, psi_a_p5_m7); - prodsum_psi_a_epi16_256(psi_r_p3_p7, a_r_p3_p7, psi_i_p3_p7, a_i_p3_p7, psi_a_p3_p7); - prodsum_psi_a_epi16_256(psi_r_p3_p5, a_r_p3_p5, psi_i_p3_p5, a_i_p3_p5, psi_a_p3_p5); - prodsum_psi_a_epi16_256(psi_r_p3_p3, a_r_p3_p3, psi_i_p3_p3, a_i_p3_p3, psi_a_p3_p3); - prodsum_psi_a_epi16_256(psi_r_p3_p1, a_r_p3_p1, psi_i_p3_p1, a_i_p3_p1, psi_a_p3_p1); - prodsum_psi_a_epi16_256(psi_r_p3_m1, a_r_p3_m1, psi_i_p3_m1, a_i_p3_m1, psi_a_p3_m1); - prodsum_psi_a_epi16_256(psi_r_p3_m3, a_r_p3_m3, psi_i_p3_m3, a_i_p3_m3, psi_a_p3_m3); - prodsum_psi_a_epi16_256(psi_r_p3_m5, a_r_p3_m5, psi_i_p3_m5, a_i_p3_m5, psi_a_p3_m5); - prodsum_psi_a_epi16_256(psi_r_p3_m7, a_r_p3_m7, psi_i_p3_m7, a_i_p3_m7, psi_a_p3_m7); - prodsum_psi_a_epi16_256(psi_r_p1_p7, a_r_p1_p7, psi_i_p1_p7, a_i_p1_p7, psi_a_p1_p7); - prodsum_psi_a_epi16_256(psi_r_p1_p5, a_r_p1_p5, psi_i_p1_p5, a_i_p1_p5, psi_a_p1_p5); - prodsum_psi_a_epi16_256(psi_r_p1_p3, a_r_p1_p3, psi_i_p1_p3, a_i_p1_p3, psi_a_p1_p3); - prodsum_psi_a_epi16_256(psi_r_p1_p1, a_r_p1_p1, psi_i_p1_p1, a_i_p1_p1, psi_a_p1_p1); - prodsum_psi_a_epi16_256(psi_r_p1_m1, a_r_p1_m1, psi_i_p1_m1, a_i_p1_m1, psi_a_p1_m1); - prodsum_psi_a_epi16_256(psi_r_p1_m3, a_r_p1_m3, psi_i_p1_m3, a_i_p1_m3, psi_a_p1_m3); - prodsum_psi_a_epi16_256(psi_r_p1_m5, a_r_p1_m5, psi_i_p1_m5, a_i_p1_m5, psi_a_p1_m5); - prodsum_psi_a_epi16_256(psi_r_p1_m7, a_r_p1_m7, psi_i_p1_m7, a_i_p1_m7, psi_a_p1_m7); - prodsum_psi_a_epi16_256(psi_r_m1_p7, a_r_m1_p7, psi_i_m1_p7, a_i_m1_p7, psi_a_m1_p7); - prodsum_psi_a_epi16_256(psi_r_m1_p5, a_r_m1_p5, psi_i_m1_p5, a_i_m1_p5, psi_a_m1_p5); - prodsum_psi_a_epi16_256(psi_r_m1_p3, a_r_m1_p3, psi_i_m1_p3, a_i_m1_p3, psi_a_m1_p3); - prodsum_psi_a_epi16_256(psi_r_m1_p1, a_r_m1_p1, psi_i_m1_p1, a_i_m1_p1, psi_a_m1_p1); - prodsum_psi_a_epi16_256(psi_r_m1_m1, a_r_m1_m1, psi_i_m1_m1, a_i_m1_m1, psi_a_m1_m1); - prodsum_psi_a_epi16_256(psi_r_m1_m3, a_r_m1_m3, psi_i_m1_m3, a_i_m1_m3, psi_a_m1_m3); - prodsum_psi_a_epi16_256(psi_r_m1_m5, a_r_m1_m5, psi_i_m1_m5, a_i_m1_m5, psi_a_m1_m5); - prodsum_psi_a_epi16_256(psi_r_m1_m7, a_r_m1_m7, psi_i_m1_m7, a_i_m1_m7, psi_a_m1_m7); - prodsum_psi_a_epi16_256(psi_r_m3_p7, a_r_m3_p7, psi_i_m3_p7, a_i_m3_p7, psi_a_m3_p7); - prodsum_psi_a_epi16_256(psi_r_m3_p5, a_r_m3_p5, psi_i_m3_p5, a_i_m3_p5, psi_a_m3_p5); - prodsum_psi_a_epi16_256(psi_r_m3_p3, a_r_m3_p3, psi_i_m3_p3, a_i_m3_p3, psi_a_m3_p3); - prodsum_psi_a_epi16_256(psi_r_m3_p1, a_r_m3_p1, psi_i_m3_p1, a_i_m3_p1, psi_a_m3_p1); - prodsum_psi_a_epi16_256(psi_r_m3_m1, a_r_m3_m1, psi_i_m3_m1, a_i_m3_m1, psi_a_m3_m1); - prodsum_psi_a_epi16_256(psi_r_m3_m3, a_r_m3_m3, psi_i_m3_m3, a_i_m3_m3, psi_a_m3_m3); - prodsum_psi_a_epi16_256(psi_r_m3_m5, a_r_m3_m5, psi_i_m3_m5, a_i_m3_m5, psi_a_m3_m5); - prodsum_psi_a_epi16_256(psi_r_m3_m7, a_r_m3_m7, psi_i_m3_m7, a_i_m3_m7, psi_a_m3_m7); - prodsum_psi_a_epi16_256(psi_r_m5_p7, a_r_m5_p7, psi_i_m5_p7, a_i_m5_p7, psi_a_m5_p7); - prodsum_psi_a_epi16_256(psi_r_m5_p5, a_r_m5_p5, psi_i_m5_p5, a_i_m5_p5, psi_a_m5_p5); - prodsum_psi_a_epi16_256(psi_r_m5_p3, a_r_m5_p3, psi_i_m5_p3, a_i_m5_p3, psi_a_m5_p3); - prodsum_psi_a_epi16_256(psi_r_m5_p1, a_r_m5_p1, psi_i_m5_p1, a_i_m5_p1, psi_a_m5_p1); - prodsum_psi_a_epi16_256(psi_r_m5_m1, a_r_m5_m1, psi_i_m5_m1, a_i_m5_m1, psi_a_m5_m1); - prodsum_psi_a_epi16_256(psi_r_m5_m3, a_r_m5_m3, psi_i_m5_m3, a_i_m5_m3, psi_a_m5_m3); - prodsum_psi_a_epi16_256(psi_r_m5_m5, a_r_m5_m5, psi_i_m5_m5, a_i_m5_m5, psi_a_m5_m5); - prodsum_psi_a_epi16_256(psi_r_m5_m7, a_r_m5_m7, psi_i_m5_m7, a_i_m5_m7, psi_a_m5_m7); - prodsum_psi_a_epi16_256(psi_r_m7_p7, a_r_m7_p7, psi_i_m7_p7, a_i_m7_p7, psi_a_m7_p7); - prodsum_psi_a_epi16_256(psi_r_m7_p5, a_r_m7_p5, psi_i_m7_p5, a_i_m7_p5, psi_a_m7_p5); - prodsum_psi_a_epi16_256(psi_r_m7_p3, a_r_m7_p3, psi_i_m7_p3, a_i_m7_p3, psi_a_m7_p3); - prodsum_psi_a_epi16_256(psi_r_m7_p1, a_r_m7_p1, psi_i_m7_p1, a_i_m7_p1, psi_a_m7_p1); - prodsum_psi_a_epi16_256(psi_r_m7_m1, a_r_m7_m1, psi_i_m7_m1, a_i_m7_m1, psi_a_m7_m1); - prodsum_psi_a_epi16_256(psi_r_m7_m3, a_r_m7_m3, psi_i_m7_m3, a_i_m7_m3, psi_a_m7_m3); - prodsum_psi_a_epi16_256(psi_r_m7_m5, a_r_m7_m5, psi_i_m7_m5, a_i_m7_m5, psi_a_m7_m5); - prodsum_psi_a_epi16_256(psi_r_m7_m7, a_r_m7_m7, psi_i_m7_m7, a_i_m7_m7, psi_a_m7_m7); + simde__m256i psi_a_p7_p7 = prodsum_psi_a_epi16_256(psi_r_p7_p7, a_r_p7_p7, psi_i_p7_p7, a_i_p7_p7); + simde__m256i psi_a_p7_p5 = prodsum_psi_a_epi16_256(psi_r_p7_p5, a_r_p7_p5, psi_i_p7_p5, a_i_p7_p5); + simde__m256i psi_a_p7_p3 = prodsum_psi_a_epi16_256(psi_r_p7_p3, a_r_p7_p3, psi_i_p7_p3, a_i_p7_p3); + simde__m256i psi_a_p7_p1 = prodsum_psi_a_epi16_256(psi_r_p7_p1, a_r_p7_p1, psi_i_p7_p1, a_i_p7_p1); + simde__m256i psi_a_p7_m1 = prodsum_psi_a_epi16_256(psi_r_p7_m1, a_r_p7_m1, psi_i_p7_m1, a_i_p7_m1); + simde__m256i psi_a_p7_m3 = prodsum_psi_a_epi16_256(psi_r_p7_m3, a_r_p7_m3, psi_i_p7_m3, a_i_p7_m3); + simde__m256i psi_a_p7_m5 = prodsum_psi_a_epi16_256(psi_r_p7_m5, a_r_p7_m5, psi_i_p7_m5, a_i_p7_m5); + simde__m256i psi_a_p7_m7 = prodsum_psi_a_epi16_256(psi_r_p7_m7, a_r_p7_m7, psi_i_p7_m7, a_i_p7_m7); + simde__m256i psi_a_p5_p7 = prodsum_psi_a_epi16_256(psi_r_p5_p7, a_r_p5_p7, psi_i_p5_p7, a_i_p5_p7); + simde__m256i psi_a_p5_p5 = prodsum_psi_a_epi16_256(psi_r_p5_p5, a_r_p5_p5, psi_i_p5_p5, a_i_p5_p5); + simde__m256i psi_a_p5_p3 = prodsum_psi_a_epi16_256(psi_r_p5_p3, a_r_p5_p3, psi_i_p5_p3, a_i_p5_p3); + simde__m256i psi_a_p5_p1 = prodsum_psi_a_epi16_256(psi_r_p5_p1, a_r_p5_p1, psi_i_p5_p1, a_i_p5_p1); + simde__m256i psi_a_p5_m1 = prodsum_psi_a_epi16_256(psi_r_p5_m1, a_r_p5_m1, psi_i_p5_m1, a_i_p5_m1); + simde__m256i psi_a_p5_m3 = prodsum_psi_a_epi16_256(psi_r_p5_m3, a_r_p5_m3, psi_i_p5_m3, a_i_p5_m3); + simde__m256i psi_a_p5_m5 = prodsum_psi_a_epi16_256(psi_r_p5_m5, a_r_p5_m5, psi_i_p5_m5, a_i_p5_m5); + simde__m256i psi_a_p5_m7 = prodsum_psi_a_epi16_256(psi_r_p5_m7, a_r_p5_m7, psi_i_p5_m7, a_i_p5_m7); + simde__m256i psi_a_p3_p7 = prodsum_psi_a_epi16_256(psi_r_p3_p7, a_r_p3_p7, psi_i_p3_p7, a_i_p3_p7); + simde__m256i psi_a_p3_p5 = prodsum_psi_a_epi16_256(psi_r_p3_p5, a_r_p3_p5, psi_i_p3_p5, a_i_p3_p5); + simde__m256i psi_a_p3_p3 = prodsum_psi_a_epi16_256(psi_r_p3_p3, a_r_p3_p3, psi_i_p3_p3, a_i_p3_p3); + simde__m256i psi_a_p3_p1 = prodsum_psi_a_epi16_256(psi_r_p3_p1, a_r_p3_p1, psi_i_p3_p1, a_i_p3_p1); + simde__m256i psi_a_p3_m1 = prodsum_psi_a_epi16_256(psi_r_p3_m1, a_r_p3_m1, psi_i_p3_m1, a_i_p3_m1); + simde__m256i psi_a_p3_m3 = prodsum_psi_a_epi16_256(psi_r_p3_m3, a_r_p3_m3, psi_i_p3_m3, a_i_p3_m3); + simde__m256i psi_a_p3_m5 = prodsum_psi_a_epi16_256(psi_r_p3_m5, a_r_p3_m5, psi_i_p3_m5, a_i_p3_m5); + simde__m256i psi_a_p3_m7 = prodsum_psi_a_epi16_256(psi_r_p3_m7, a_r_p3_m7, psi_i_p3_m7, a_i_p3_m7); + simde__m256i psi_a_p1_p7 = prodsum_psi_a_epi16_256(psi_r_p1_p7, a_r_p1_p7, psi_i_p1_p7, a_i_p1_p7); + simde__m256i psi_a_p1_p5 = prodsum_psi_a_epi16_256(psi_r_p1_p5, a_r_p1_p5, psi_i_p1_p5, a_i_p1_p5); + simde__m256i psi_a_p1_p3 = prodsum_psi_a_epi16_256(psi_r_p1_p3, a_r_p1_p3, psi_i_p1_p3, a_i_p1_p3); + simde__m256i psi_a_p1_p1 = prodsum_psi_a_epi16_256(psi_r_p1_p1, a_r_p1_p1, psi_i_p1_p1, a_i_p1_p1); + simde__m256i psi_a_p1_m1 = prodsum_psi_a_epi16_256(psi_r_p1_m1, a_r_p1_m1, psi_i_p1_m1, a_i_p1_m1); + simde__m256i psi_a_p1_m3 = prodsum_psi_a_epi16_256(psi_r_p1_m3, a_r_p1_m3, psi_i_p1_m3, a_i_p1_m3); + simde__m256i psi_a_p1_m5 = prodsum_psi_a_epi16_256(psi_r_p1_m5, a_r_p1_m5, psi_i_p1_m5, a_i_p1_m5); + simde__m256i psi_a_p1_m7 = prodsum_psi_a_epi16_256(psi_r_p1_m7, a_r_p1_m7, psi_i_p1_m7, a_i_p1_m7); + simde__m256i psi_a_m1_p7 = prodsum_psi_a_epi16_256(psi_r_m1_p7, a_r_m1_p7, psi_i_m1_p7, a_i_m1_p7); + simde__m256i psi_a_m1_p5 = prodsum_psi_a_epi16_256(psi_r_m1_p5, a_r_m1_p5, psi_i_m1_p5, a_i_m1_p5); + simde__m256i psi_a_m1_p3 = prodsum_psi_a_epi16_256(psi_r_m1_p3, a_r_m1_p3, psi_i_m1_p3, a_i_m1_p3); + simde__m256i psi_a_m1_p1 = prodsum_psi_a_epi16_256(psi_r_m1_p1, a_r_m1_p1, psi_i_m1_p1, a_i_m1_p1); + simde__m256i psi_a_m1_m1 = prodsum_psi_a_epi16_256(psi_r_m1_m1, a_r_m1_m1, psi_i_m1_m1, a_i_m1_m1); + simde__m256i psi_a_m1_m3 = prodsum_psi_a_epi16_256(psi_r_m1_m3, a_r_m1_m3, psi_i_m1_m3, a_i_m1_m3); + simde__m256i psi_a_m1_m5 = prodsum_psi_a_epi16_256(psi_r_m1_m5, a_r_m1_m5, psi_i_m1_m5, a_i_m1_m5); + simde__m256i psi_a_m1_m7 = prodsum_psi_a_epi16_256(psi_r_m1_m7, a_r_m1_m7, psi_i_m1_m7, a_i_m1_m7); + simde__m256i psi_a_m3_p7 = prodsum_psi_a_epi16_256(psi_r_m3_p7, a_r_m3_p7, psi_i_m3_p7, a_i_m3_p7); + simde__m256i psi_a_m3_p5 = prodsum_psi_a_epi16_256(psi_r_m3_p5, a_r_m3_p5, psi_i_m3_p5, a_i_m3_p5); + simde__m256i psi_a_m3_p3 = prodsum_psi_a_epi16_256(psi_r_m3_p3, a_r_m3_p3, psi_i_m3_p3, a_i_m3_p3); + simde__m256i psi_a_m3_p1 = prodsum_psi_a_epi16_256(psi_r_m3_p1, a_r_m3_p1, psi_i_m3_p1, a_i_m3_p1); + simde__m256i psi_a_m3_m1 = prodsum_psi_a_epi16_256(psi_r_m3_m1, a_r_m3_m1, psi_i_m3_m1, a_i_m3_m1); + simde__m256i psi_a_m3_m3 = prodsum_psi_a_epi16_256(psi_r_m3_m3, a_r_m3_m3, psi_i_m3_m3, a_i_m3_m3); + simde__m256i psi_a_m3_m5 = prodsum_psi_a_epi16_256(psi_r_m3_m5, a_r_m3_m5, psi_i_m3_m5, a_i_m3_m5); + simde__m256i psi_a_m3_m7 = prodsum_psi_a_epi16_256(psi_r_m3_m7, a_r_m3_m7, psi_i_m3_m7, a_i_m3_m7); + simde__m256i psi_a_m5_p7 = prodsum_psi_a_epi16_256(psi_r_m5_p7, a_r_m5_p7, psi_i_m5_p7, a_i_m5_p7); + simde__m256i psi_a_m5_p5 = prodsum_psi_a_epi16_256(psi_r_m5_p5, a_r_m5_p5, psi_i_m5_p5, a_i_m5_p5); + simde__m256i psi_a_m5_p3 = prodsum_psi_a_epi16_256(psi_r_m5_p3, a_r_m5_p3, psi_i_m5_p3, a_i_m5_p3); + simde__m256i psi_a_m5_p1 = prodsum_psi_a_epi16_256(psi_r_m5_p1, a_r_m5_p1, psi_i_m5_p1, a_i_m5_p1); + simde__m256i psi_a_m5_m1 = prodsum_psi_a_epi16_256(psi_r_m5_m1, a_r_m5_m1, psi_i_m5_m1, a_i_m5_m1); + simde__m256i psi_a_m5_m3 = prodsum_psi_a_epi16_256(psi_r_m5_m3, a_r_m5_m3, psi_i_m5_m3, a_i_m5_m3); + simde__m256i psi_a_m5_m5 = prodsum_psi_a_epi16_256(psi_r_m5_m5, a_r_m5_m5, psi_i_m5_m5, a_i_m5_m5); + simde__m256i psi_a_m5_m7 = prodsum_psi_a_epi16_256(psi_r_m5_m7, a_r_m5_m7, psi_i_m5_m7, a_i_m5_m7); + simde__m256i psi_a_m7_p7 = prodsum_psi_a_epi16_256(psi_r_m7_p7, a_r_m7_p7, psi_i_m7_p7, a_i_m7_p7); + simde__m256i psi_a_m7_p5 = prodsum_psi_a_epi16_256(psi_r_m7_p5, a_r_m7_p5, psi_i_m7_p5, a_i_m7_p5); + simde__m256i psi_a_m7_p3 = prodsum_psi_a_epi16_256(psi_r_m7_p3, a_r_m7_p3, psi_i_m7_p3, a_i_m7_p3); + simde__m256i psi_a_m7_p1 = prodsum_psi_a_epi16_256(psi_r_m7_p1, a_r_m7_p1, psi_i_m7_p1, a_i_m7_p1); + simde__m256i psi_a_m7_m1 = prodsum_psi_a_epi16_256(psi_r_m7_m1, a_r_m7_m1, psi_i_m7_m1, a_i_m7_m1); + simde__m256i psi_a_m7_m3 = prodsum_psi_a_epi16_256(psi_r_m7_m3, a_r_m7_m3, psi_i_m7_m3, a_i_m7_m3); + simde__m256i psi_a_m7_m5 = prodsum_psi_a_epi16_256(psi_r_m7_m5, a_r_m7_m5, psi_i_m7_m5, a_i_m7_m5); + simde__m256i psi_a_m7_m7 = prodsum_psi_a_epi16_256(psi_r_m7_m7, a_r_m7_m7, psi_i_m7_m7, a_i_m7_m7); // Multiply by sqrt(2) psi_a_p7_p7 = simde_mm256_mulhi_epi16(psi_a_p7_p7, ONE_OVER_SQRT_2); @@ -6195,70 +5959,70 @@ void nr_ulsch_qam64_qam64(c16_t *stream0_in, psi_a_m7_m7 = simde_mm256_slli_epi16(psi_a_m7_m7, 2); // Calculation of a group of two terms in the bit metric involving squares of interference - square_a_64qam_epi16_256(a_r_p7_p7, a_i_p7_p7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p7_p7); - square_a_64qam_epi16_256(a_r_p7_p5, a_i_p7_p5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p7_p5); - square_a_64qam_epi16_256(a_r_p7_p3, a_i_p7_p3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p7_p3); - square_a_64qam_epi16_256(a_r_p7_p1, a_i_p7_p1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p7_p1); - square_a_64qam_epi16_256(a_r_p7_m1, a_i_p7_m1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p7_m1); - square_a_64qam_epi16_256(a_r_p7_m3, a_i_p7_m3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p7_m3); - square_a_64qam_epi16_256(a_r_p7_m5, a_i_p7_m5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p7_m5); - square_a_64qam_epi16_256(a_r_p7_m7, a_i_p7_m7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p7_m7); - square_a_64qam_epi16_256(a_r_p5_p7, a_i_p5_p7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p5_p7); - square_a_64qam_epi16_256(a_r_p5_p5, a_i_p5_p5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p5_p5); - square_a_64qam_epi16_256(a_r_p5_p3, a_i_p5_p3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p5_p3); - square_a_64qam_epi16_256(a_r_p5_p1, a_i_p5_p1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p5_p1); - square_a_64qam_epi16_256(a_r_p5_m1, a_i_p5_m1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p5_m1); - square_a_64qam_epi16_256(a_r_p5_m3, a_i_p5_m3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p5_m3); - square_a_64qam_epi16_256(a_r_p5_m5, a_i_p5_m5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p5_m5); - square_a_64qam_epi16_256(a_r_p5_m7, a_i_p5_m7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p5_m7); - square_a_64qam_epi16_256(a_r_p3_p7, a_i_p3_p7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p3_p7); - square_a_64qam_epi16_256(a_r_p3_p5, a_i_p3_p5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p3_p5); - square_a_64qam_epi16_256(a_r_p3_p3, a_i_p3_p3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p3_p3); - square_a_64qam_epi16_256(a_r_p3_p1, a_i_p3_p1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p3_p1); - square_a_64qam_epi16_256(a_r_p3_m1, a_i_p3_m1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p3_m1); - square_a_64qam_epi16_256(a_r_p3_m3, a_i_p3_m3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p3_m3); - square_a_64qam_epi16_256(a_r_p3_m5, a_i_p3_m5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p3_m5); - square_a_64qam_epi16_256(a_r_p3_m7, a_i_p3_m7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p3_m7); - square_a_64qam_epi16_256(a_r_p1_p7, a_i_p1_p7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p1_p7); - square_a_64qam_epi16_256(a_r_p1_p5, a_i_p1_p5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p1_p5); - square_a_64qam_epi16_256(a_r_p1_p3, a_i_p1_p3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p1_p3); - square_a_64qam_epi16_256(a_r_p1_p1, a_i_p1_p1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p1_p1); - square_a_64qam_epi16_256(a_r_p1_m1, a_i_p1_m1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p1_m1); - square_a_64qam_epi16_256(a_r_p1_m3, a_i_p1_m3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p1_m3); - square_a_64qam_epi16_256(a_r_p1_m5, a_i_p1_m5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p1_m5); - square_a_64qam_epi16_256(a_r_p1_m7, a_i_p1_m7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_p1_m7); - square_a_64qam_epi16_256(a_r_m1_p7, a_i_m1_p7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m1_p7); - square_a_64qam_epi16_256(a_r_m1_p5, a_i_m1_p5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m1_p5); - square_a_64qam_epi16_256(a_r_m1_p3, a_i_m1_p3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m1_p3); - square_a_64qam_epi16_256(a_r_m1_p1, a_i_m1_p1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m1_p1); - square_a_64qam_epi16_256(a_r_m1_m1, a_i_m1_m1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m1_m1); - square_a_64qam_epi16_256(a_r_m1_m3, a_i_m1_m3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m1_m3); - square_a_64qam_epi16_256(a_r_m1_m5, a_i_m1_m5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m1_m5); - square_a_64qam_epi16_256(a_r_m1_m7, a_i_m1_m7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m1_m7); - square_a_64qam_epi16_256(a_r_m3_p7, a_i_m3_p7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m3_p7); - square_a_64qam_epi16_256(a_r_m3_p5, a_i_m3_p5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m3_p5); - square_a_64qam_epi16_256(a_r_m3_p3, a_i_m3_p3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m3_p3); - square_a_64qam_epi16_256(a_r_m3_p1, a_i_m3_p1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m3_p1); - square_a_64qam_epi16_256(a_r_m3_m1, a_i_m3_m1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m3_m1); - square_a_64qam_epi16_256(a_r_m3_m3, a_i_m3_m3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m3_m3); - square_a_64qam_epi16_256(a_r_m3_m5, a_i_m3_m5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m3_m5); - square_a_64qam_epi16_256(a_r_m3_m7, a_i_m3_m7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m3_m7); - square_a_64qam_epi16_256(a_r_m5_p7, a_i_m5_p7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m5_p7); - square_a_64qam_epi16_256(a_r_m5_p5, a_i_m5_p5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m5_p5); - square_a_64qam_epi16_256(a_r_m5_p3, a_i_m5_p3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m5_p3); - square_a_64qam_epi16_256(a_r_m5_p1, a_i_m5_p1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m5_p1); - square_a_64qam_epi16_256(a_r_m5_m1, a_i_m5_m1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m5_m1); - square_a_64qam_epi16_256(a_r_m5_m3, a_i_m5_m3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m5_m3); - square_a_64qam_epi16_256(a_r_m5_m5, a_i_m5_m5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m5_m5); - square_a_64qam_epi16_256(a_r_m5_m7, a_i_m5_m7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m5_m7); - square_a_64qam_epi16_256(a_r_m7_p7, a_i_m7_p7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m7_p7); - square_a_64qam_epi16_256(a_r_m7_p5, a_i_m7_p5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m7_p5); - square_a_64qam_epi16_256(a_r_m7_p3, a_i_m7_p3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m7_p3); - square_a_64qam_epi16_256(a_r_m7_p1, a_i_m7_p1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m7_p1); - square_a_64qam_epi16_256(a_r_m7_m1, a_i_m7_m1, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m7_m1); - square_a_64qam_epi16_256(a_r_m7_m3, a_i_m7_m3, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m7_m3); - square_a_64qam_epi16_256(a_r_m7_m5, a_i_m7_m5, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m7_m5); - square_a_64qam_epi16_256(a_r_m7_m7, a_i_m7_m7, ch_mag_int, SQRT_42_OVER_FOUR, a_sq_m7_m7); + simde__m256i a_sq_p7_p7 = square_a_64qam_epi16_256(a_r_p7_p7, a_i_p7_p7, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_p7_p5 = square_a_64qam_epi16_256(a_r_p7_p5, a_i_p7_p5, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_p7_p3 = square_a_64qam_epi16_256(a_r_p7_p3, a_i_p7_p3, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_p7_p1 = square_a_64qam_epi16_256(a_r_p7_p1, a_i_p7_p1, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_p7_m1 = square_a_64qam_epi16_256(a_r_p7_m1, a_i_p7_m1, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_p7_m3 = square_a_64qam_epi16_256(a_r_p7_m3, a_i_p7_m3, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_p7_m5 = square_a_64qam_epi16_256(a_r_p7_m5, a_i_p7_m5, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_p7_m7 = square_a_64qam_epi16_256(a_r_p7_m7, a_i_p7_m7, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_p5_p7 = square_a_64qam_epi16_256(a_r_p5_p7, a_i_p5_p7, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_p5_p5 = square_a_64qam_epi16_256(a_r_p5_p5, a_i_p5_p5, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_p5_p3 = square_a_64qam_epi16_256(a_r_p5_p3, a_i_p5_p3, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_p5_p1 = square_a_64qam_epi16_256(a_r_p5_p1, a_i_p5_p1, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_p5_m1 = square_a_64qam_epi16_256(a_r_p5_m1, a_i_p5_m1, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_p5_m3 = square_a_64qam_epi16_256(a_r_p5_m3, a_i_p5_m3, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_p5_m5 = square_a_64qam_epi16_256(a_r_p5_m5, a_i_p5_m5, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_p5_m7 = square_a_64qam_epi16_256(a_r_p5_m7, a_i_p5_m7, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_p3_p7 = square_a_64qam_epi16_256(a_r_p3_p7, a_i_p3_p7, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_p3_p5 = square_a_64qam_epi16_256(a_r_p3_p5, a_i_p3_p5, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_p3_p3 = square_a_64qam_epi16_256(a_r_p3_p3, a_i_p3_p3, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_p3_p1 = square_a_64qam_epi16_256(a_r_p3_p1, a_i_p3_p1, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_p3_m1 = square_a_64qam_epi16_256(a_r_p3_m1, a_i_p3_m1, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_p3_m3 = square_a_64qam_epi16_256(a_r_p3_m3, a_i_p3_m3, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_p3_m5 = square_a_64qam_epi16_256(a_r_p3_m5, a_i_p3_m5, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_p3_m7 = square_a_64qam_epi16_256(a_r_p3_m7, a_i_p3_m7, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_p1_p7 = square_a_64qam_epi16_256(a_r_p1_p7, a_i_p1_p7, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_p1_p5 = square_a_64qam_epi16_256(a_r_p1_p5, a_i_p1_p5, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_p1_p3 = square_a_64qam_epi16_256(a_r_p1_p3, a_i_p1_p3, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_p1_p1 = square_a_64qam_epi16_256(a_r_p1_p1, a_i_p1_p1, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_p1_m1 = square_a_64qam_epi16_256(a_r_p1_m1, a_i_p1_m1, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_p1_m3 = square_a_64qam_epi16_256(a_r_p1_m3, a_i_p1_m3, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_p1_m5 = square_a_64qam_epi16_256(a_r_p1_m5, a_i_p1_m5, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_p1_m7 = square_a_64qam_epi16_256(a_r_p1_m7, a_i_p1_m7, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_m1_p7 = square_a_64qam_epi16_256(a_r_m1_p7, a_i_m1_p7, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_m1_p5 = square_a_64qam_epi16_256(a_r_m1_p5, a_i_m1_p5, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_m1_p3 = square_a_64qam_epi16_256(a_r_m1_p3, a_i_m1_p3, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_m1_p1 = square_a_64qam_epi16_256(a_r_m1_p1, a_i_m1_p1, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_m1_m1 = square_a_64qam_epi16_256(a_r_m1_m1, a_i_m1_m1, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_m1_m3 = square_a_64qam_epi16_256(a_r_m1_m3, a_i_m1_m3, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_m1_m5 = square_a_64qam_epi16_256(a_r_m1_m5, a_i_m1_m5, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_m1_m7 = square_a_64qam_epi16_256(a_r_m1_m7, a_i_m1_m7, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_m3_p7 = square_a_64qam_epi16_256(a_r_m3_p7, a_i_m3_p7, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_m3_p5 = square_a_64qam_epi16_256(a_r_m3_p5, a_i_m3_p5, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_m3_p3 = square_a_64qam_epi16_256(a_r_m3_p3, a_i_m3_p3, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_m3_p1 = square_a_64qam_epi16_256(a_r_m3_p1, a_i_m3_p1, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_m3_m1 = square_a_64qam_epi16_256(a_r_m3_m1, a_i_m3_m1, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_m3_m3 = square_a_64qam_epi16_256(a_r_m3_m3, a_i_m3_m3, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_m3_m5 = square_a_64qam_epi16_256(a_r_m3_m5, a_i_m3_m5, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_m3_m7 = square_a_64qam_epi16_256(a_r_m3_m7, a_i_m3_m7, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_m5_p7 = square_a_64qam_epi16_256(a_r_m5_p7, a_i_m5_p7, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_m5_p5 = square_a_64qam_epi16_256(a_r_m5_p5, a_i_m5_p5, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_m5_p3 = square_a_64qam_epi16_256(a_r_m5_p3, a_i_m5_p3, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_m5_p1 = square_a_64qam_epi16_256(a_r_m5_p1, a_i_m5_p1, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_m5_m1 = square_a_64qam_epi16_256(a_r_m5_m1, a_i_m5_m1, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_m5_m3 = square_a_64qam_epi16_256(a_r_m5_m3, a_i_m5_m3, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_m5_m5 = square_a_64qam_epi16_256(a_r_m5_m5, a_i_m5_m5, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_m5_m7 = square_a_64qam_epi16_256(a_r_m5_m7, a_i_m5_m7, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_m7_p7 = square_a_64qam_epi16_256(a_r_m7_p7, a_i_m7_p7, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_m7_p5 = square_a_64qam_epi16_256(a_r_m7_p5, a_i_m7_p5, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_m7_p3 = square_a_64qam_epi16_256(a_r_m7_p3, a_i_m7_p3, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_m7_p1 = square_a_64qam_epi16_256(a_r_m7_p1, a_i_m7_p1, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_m7_m1 = square_a_64qam_epi16_256(a_r_m7_m1, a_i_m7_m1, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_m7_m3 = square_a_64qam_epi16_256(a_r_m7_m3, a_i_m7_m3, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_m7_m5 = square_a_64qam_epi16_256(a_r_m7_m5, a_i_m7_m5, ch_mag_int, SQRT_42_OVER_FOUR); + simde__m256i a_sq_m7_m7 = square_a_64qam_epi16_256(a_r_m7_m7, a_i_m7_m7, ch_mag_int, SQRT_42_OVER_FOUR); // Computing different multiples of ||h0||^2 // x=1, y=1 From 3ce1f6517dd1ac70630a6798cf84a41ec8d24add Mon Sep 17 00:00:00 2001 From: Quency Date: Wed, 12 Jul 2023 16:30:52 +0200 Subject: [PATCH 12/47] fix / warnings in nr_ulsch_llr_computation.c --- .../NR_TRANSPORT/nr_ulsch_llr_computation.c | 283 +++++++++--------- 1 file changed, 136 insertions(+), 147 deletions(-) diff --git a/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c b/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c index d1735b5377..430e66041e 100644 --- a/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c +++ b/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c @@ -655,27 +655,27 @@ static inline simde__m256i prodsum_psi_a_epi16_256(simde__m256i psi_r, simde__m2 } // Calculate interference magnitude -static inline void interference_abs_epi16(simde__m128i psi, simde__m128i int_ch_mag, simde__m128i int_mag, simde__m128i c1, simde__m128i c2) +static inline simde__m128i interference_abs_epi16(simde__m128i psi, simde__m128i int_ch_mag, simde__m128i c1, simde__m128i c2) { simde__m128i tmp_result = simde_mm_cmplt_epi16(psi, int_ch_mag); simde__m128i tmp_result2 = simde_mm_xor_si128(tmp_result, (*(simde__m128i *)&ones[0])); tmp_result = simde_mm_and_si128(tmp_result, c1); tmp_result2 = simde_mm_and_si128(tmp_result2, c2); - int_mag = simde_mm_or_si128(tmp_result, tmp_result2); + return simde_mm_or_si128(tmp_result, tmp_result2); } // Calculate interference magnitude -static inline void interference_abs_epi16_256(simde__m256i psi, simde__m256i int_ch_mag, simde__m256i int_mag, simde__m256i c1, simde__m256i c2) +static inline simde__m256i interference_abs_epi16_256(simde__m256i psi, simde__m256i int_ch_mag, simde__m256i c1, simde__m256i c2) { simde__m256i tmp_result = simde_mm256_cmpgt_epi16(int_ch_mag, psi); simde__m256i tmp_result2 = simde_mm256_xor_si256(tmp_result, (*(simde__m256i *)&ones256[0])); tmp_result = simde_mm256_and_si256(tmp_result, c1); tmp_result2 = simde_mm256_and_si256(tmp_result2, c2); - int_mag = simde_mm256_or_si256(tmp_result, tmp_result2); + return simde_mm256_or_si256(tmp_result, tmp_result2); } // Calculates a_sq = int_ch_mag * (a_r^2 + a_i^2) * scale_factor -static inline void square_a_epi16(simde__m128i a_r, simde__m128i a_i, simde__m128i int_ch_mag, simde__m128i scale_factor, simde__m128i a_sq) +static inline simde__m128i square_a_epi16(simde__m128i a_r, simde__m128i a_i, simde__m128i int_ch_mag, simde__m128i scale_factor) { simde__m128i tmp_result = simde_mm_mulhi_epi16(a_r, a_r); tmp_result = simde_mm_slli_epi16(tmp_result, 1); @@ -689,11 +689,11 @@ static inline void square_a_epi16(simde__m128i a_r, simde__m128i a_i, simde__m12 tmp_result2 = simde_mm_slli_epi16(tmp_result2, 1); tmp_result2 = simde_mm_mulhi_epi16(tmp_result2, int_ch_mag); tmp_result2 = simde_mm_slli_epi16(tmp_result2, 1); - a_sq = simde_mm_adds_epi16(tmp_result, tmp_result2); + return simde_mm_adds_epi16(tmp_result, tmp_result2); } // Calculates a_sq = int_ch_mag * (a_r^2 + a_i^2) * scale_factor -static inline void square_a_epi16_256(simde__m256i a_r, simde__m256i a_i, simde__m256i int_ch_mag, simde__m256i scale_factor, simde__m256i a_sq) +static inline simde__m256i square_a_epi16_256(simde__m256i a_r, simde__m256i a_i, simde__m256i int_ch_mag, simde__m256i scale_factor) { simde__m256i tmp_result = simde_mm256_mulhi_epi16(a_r, a_r); tmp_result = simde_mm256_slli_epi16(tmp_result, 1); @@ -707,7 +707,7 @@ static inline void square_a_epi16_256(simde__m256i a_r, simde__m256i a_i, simde_ tmp_result2 = simde_mm256_slli_epi16(tmp_result2, 1); tmp_result2 = simde_mm256_mulhi_epi16(tmp_result2, int_ch_mag); tmp_result2 = simde_mm256_slli_epi16(tmp_result2, 1); - a_sq = simde_mm256_adds_epi16(tmp_result, tmp_result2); + return simde_mm256_adds_epi16(tmp_result, tmp_result2); } // calculates a_sq = int_ch_mag*(a_r^2 + a_i^2)*scale_factor for 64-QAM @@ -951,9 +951,6 @@ void nr_ulsch_qam16_qam16(c16_t *stream0_in, simde__m128i y1r __attribute__((aligned(16))); simde__m128i y1i __attribute__((aligned(16))); - simde__m128i tmp_result __attribute__((aligned(16))); - simde__m128i tmp_result2 __attribute__((aligned(16))); - // In one iteration, we deal with 8 REs for (int i = 0; i < length >> 2; i += 2) { @@ -1086,74 +1083,74 @@ void nr_ulsch_qam16_qam16(c16_t *stream0_in, y0_m_3_3 = simde_mm_subs_epi16(y0r_three_over_sqrt10, y0i_three_over_sqrt10); // Compute optimal interfering symbol magnitude - interference_abs_epi16(psi_r_p1_p1, ch_mag_int, a_r_p1_p1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16(psi_i_p1_p1, ch_mag_int, a_i_p1_p1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16(psi_r_p1_p3, ch_mag_int, a_r_p1_p3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16(psi_i_p1_p3, ch_mag_int, a_i_p1_p3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16(psi_r_p1_m1, ch_mag_int, a_r_p1_m1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16(psi_i_p1_m1, ch_mag_int, a_i_p1_m1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16(psi_r_p1_m3, ch_mag_int, a_r_p1_m3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16(psi_i_p1_m3, ch_mag_int, a_i_p1_m3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16(psi_r_p3_p1, ch_mag_int, a_r_p3_p1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16(psi_i_p3_p1, ch_mag_int, a_i_p3_p1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16(psi_r_p3_p3, ch_mag_int, a_r_p3_p3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16(psi_i_p3_p3, ch_mag_int, a_i_p3_p3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16(psi_r_p3_m1, ch_mag_int, a_r_p3_m1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16(psi_i_p3_m1, ch_mag_int, a_i_p3_m1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16(psi_r_p3_m3, ch_mag_int, a_r_p3_m3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16(psi_i_p3_m3, ch_mag_int, a_i_p3_m3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16(psi_r_m1_p1, ch_mag_int, a_r_m1_p1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16(psi_i_m1_p1, ch_mag_int, a_i_m1_p1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16(psi_r_m1_p3, ch_mag_int, a_r_m1_p3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16(psi_i_m1_p3, ch_mag_int, a_i_m1_p3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16(psi_r_m1_m1, ch_mag_int, a_r_m1_m1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16(psi_i_m1_m1, ch_mag_int, a_i_m1_m1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16(psi_r_m1_m3, ch_mag_int, a_r_m1_m3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16(psi_i_m1_m3, ch_mag_int, a_i_m1_m3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16(psi_r_m3_p1, ch_mag_int, a_r_m3_p1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16(psi_i_m3_p1, ch_mag_int, a_i_m3_p1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16(psi_r_m3_p3, ch_mag_int, a_r_m3_p3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16(psi_i_m3_p3, ch_mag_int, a_i_m3_p3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16(psi_r_m3_m1, ch_mag_int, a_r_m3_m1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16(psi_i_m3_m1, ch_mag_int, a_i_m3_m1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16(psi_r_m3_m3, ch_mag_int, a_r_m3_m3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16(psi_i_m3_m3, ch_mag_int, a_i_m3_m3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_r_p1_p1 = interference_abs_epi16(psi_r_p1_p1, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_i_p1_p1 = interference_abs_epi16(psi_i_p1_p1, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_r_p1_p3 = interference_abs_epi16(psi_r_p1_p3, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_i_p1_p3 = interference_abs_epi16(psi_i_p1_p3, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_r_p1_m1 = interference_abs_epi16(psi_r_p1_m1, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_i_p1_m1 = interference_abs_epi16(psi_i_p1_m1, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_r_p1_m3 = interference_abs_epi16(psi_r_p1_m3, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_i_p1_m3 = interference_abs_epi16(psi_i_p1_m3, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_r_p3_p1 = interference_abs_epi16(psi_r_p3_p1, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_i_p3_p1 = interference_abs_epi16(psi_i_p3_p1, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_r_p3_p3 = interference_abs_epi16(psi_r_p3_p3, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_i_p3_p3 = interference_abs_epi16(psi_i_p3_p3, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_r_p3_m1 = interference_abs_epi16(psi_r_p3_m1, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_i_p3_m1 = interference_abs_epi16(psi_i_p3_m1, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_r_p3_m3 = interference_abs_epi16(psi_r_p3_m3, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_i_p3_m3 = interference_abs_epi16(psi_i_p3_m3, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_r_m1_p1 = interference_abs_epi16(psi_r_m1_p1, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_i_m1_p1 = interference_abs_epi16(psi_i_m1_p1, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_r_m1_p3 = interference_abs_epi16(psi_r_m1_p3, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_i_m1_p3 = interference_abs_epi16(psi_i_m1_p3, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_r_m1_m1 = interference_abs_epi16(psi_r_m1_m1, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_i_m1_m1 = interference_abs_epi16(psi_i_m1_m1, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_r_m1_m3 = interference_abs_epi16(psi_r_m1_m3, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_i_m1_m3 = interference_abs_epi16(psi_i_m1_m3, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_r_m3_p1 = interference_abs_epi16(psi_r_m3_p1, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_i_m3_p1 = interference_abs_epi16(psi_i_m3_p1, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_r_m3_p3 = interference_abs_epi16(psi_r_m3_p3, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_i_m3_p3 = interference_abs_epi16(psi_i_m3_p3, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_r_m3_m1 = interference_abs_epi16(psi_r_m3_m1, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_i_m3_m1 = interference_abs_epi16(psi_i_m3_m1, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_r_m3_m3 = interference_abs_epi16(psi_r_m3_m3, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_i_m3_m3 = interference_abs_epi16(psi_i_m3_m3, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); // Calculation of groups of two terms in the bit metric involving product of psi and interference magnitude - simde__m128i psi_a_p1_p1 = prodsum_psi_a_epi16(psi_r_p1_p1, a_r_p1_p1, psi_i_p1_p1, a_i_p1_p1); - simde__m128i psi_a_p1_p3 = prodsum_psi_a_epi16(psi_r_p1_p3, a_r_p1_p3, psi_i_p1_p3, a_i_p1_p3); - simde__m128i psi_a_p3_p1 = prodsum_psi_a_epi16(psi_r_p3_p1, a_r_p3_p1, psi_i_p3_p1, a_i_p3_p1); - simde__m128i psi_a_p3_p3 = prodsum_psi_a_epi16(psi_r_p3_p3, a_r_p3_p3, psi_i_p3_p3, a_i_p3_p3); - simde__m128i psi_a_p1_m1 = prodsum_psi_a_epi16(psi_r_p1_m1, a_r_p1_m1, psi_i_p1_m1, a_i_p1_m1); - simde__m128i psi_a_p1_m3 = prodsum_psi_a_epi16(psi_r_p1_m3, a_r_p1_m3, psi_i_p1_m3, a_i_p1_m3); - simde__m128i psi_a_p3_m1 = prodsum_psi_a_epi16(psi_r_p3_m1, a_r_p3_m1, psi_i_p3_m1, a_i_p3_m1); - simde__m128i psi_a_p3_m3 = prodsum_psi_a_epi16(psi_r_p3_m3, a_r_p3_m3, psi_i_p3_m3, a_i_p3_m3); - simde__m128i psi_a_m1_p1 = prodsum_psi_a_epi16(psi_r_m1_p1, a_r_m1_p1, psi_i_m1_p1, a_i_m1_p1); - simde__m128i psi_a_m1_p3 = prodsum_psi_a_epi16(psi_r_m1_p3, a_r_m1_p3, psi_i_m1_p3, a_i_m1_p3); - simde__m128i psi_a_m3_p1 = prodsum_psi_a_epi16(psi_r_m3_p1, a_r_m3_p1, psi_i_m3_p1, a_i_m3_p1); - simde__m128i psi_a_m3_p3 = prodsum_psi_a_epi16(psi_r_m3_p3, a_r_m3_p3, psi_i_m3_p3, a_i_m3_p3); - simde__m128i psi_a_m1_m1 = prodsum_psi_a_epi16(psi_r_m1_m1, a_r_m1_m1, psi_i_m1_m1, a_i_m1_m1); - simde__m128i psi_a_m1_m3 = prodsum_psi_a_epi16(psi_r_m1_m3, a_r_m1_m3, psi_i_m1_m3, a_i_m1_m3); - simde__m128i psi_a_m3_m1 = prodsum_psi_a_epi16(psi_r_m3_m1, a_r_m3_m1, psi_i_m3_m1, a_i_m3_m1); - simde__m128i psi_a_m3_m3 = prodsum_psi_a_epi16(psi_r_m3_m3, a_r_m3_m3, psi_i_m3_m3, a_i_m3_m3); + psi_a_p1_p1 = prodsum_psi_a_epi16(psi_r_p1_p1, a_r_p1_p1, psi_i_p1_p1, a_i_p1_p1); + psi_a_p1_p3 = prodsum_psi_a_epi16(psi_r_p1_p3, a_r_p1_p3, psi_i_p1_p3, a_i_p1_p3); + psi_a_p3_p1 = prodsum_psi_a_epi16(psi_r_p3_p1, a_r_p3_p1, psi_i_p3_p1, a_i_p3_p1); + psi_a_p3_p3 = prodsum_psi_a_epi16(psi_r_p3_p3, a_r_p3_p3, psi_i_p3_p3, a_i_p3_p3); + psi_a_p1_m1 = prodsum_psi_a_epi16(psi_r_p1_m1, a_r_p1_m1, psi_i_p1_m1, a_i_p1_m1); + psi_a_p1_m3 = prodsum_psi_a_epi16(psi_r_p1_m3, a_r_p1_m3, psi_i_p1_m3, a_i_p1_m3); + psi_a_p3_m1 = prodsum_psi_a_epi16(psi_r_p3_m1, a_r_p3_m1, psi_i_p3_m1, a_i_p3_m1); + psi_a_p3_m3 = prodsum_psi_a_epi16(psi_r_p3_m3, a_r_p3_m3, psi_i_p3_m3, a_i_p3_m3); + psi_a_m1_p1 = prodsum_psi_a_epi16(psi_r_m1_p1, a_r_m1_p1, psi_i_m1_p1, a_i_m1_p1); + psi_a_m1_p3 = prodsum_psi_a_epi16(psi_r_m1_p3, a_r_m1_p3, psi_i_m1_p3, a_i_m1_p3); + psi_a_m3_p1 = prodsum_psi_a_epi16(psi_r_m3_p1, a_r_m3_p1, psi_i_m3_p1, a_i_m3_p1); + psi_a_m3_p3 = prodsum_psi_a_epi16(psi_r_m3_p3, a_r_m3_p3, psi_i_m3_p3, a_i_m3_p3); + psi_a_m1_m1 = prodsum_psi_a_epi16(psi_r_m1_m1, a_r_m1_m1, psi_i_m1_m1, a_i_m1_m1); + psi_a_m1_m3 = prodsum_psi_a_epi16(psi_r_m1_m3, a_r_m1_m3, psi_i_m1_m3, a_i_m1_m3); + psi_a_m3_m1 = prodsum_psi_a_epi16(psi_r_m3_m1, a_r_m3_m1, psi_i_m3_m1, a_i_m3_m1); + psi_a_m3_m3 = prodsum_psi_a_epi16(psi_r_m3_m3, a_r_m3_m3, psi_i_m3_m3, a_i_m3_m3); // squared interference magnitude times int. ch. power - square_a_epi16(a_r_p1_p1, a_i_p1_p1, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_p1_p1); - square_a_epi16(a_r_p1_p3, a_i_p1_p3, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_p1_p3); - square_a_epi16(a_r_p3_p1, a_i_p3_p1, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_p3_p1); - square_a_epi16(a_r_p3_p3, a_i_p3_p3, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_p3_p3); - square_a_epi16(a_r_p1_m1, a_i_p1_m1, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_p1_m1); - square_a_epi16(a_r_p1_m3, a_i_p1_m3, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_p1_m3); - square_a_epi16(a_r_p3_m1, a_i_p3_m1, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_p3_m1); - square_a_epi16(a_r_p3_m3, a_i_p3_m3, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_p3_m3); - square_a_epi16(a_r_m1_p1, a_i_m1_p1, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_m1_p1); - square_a_epi16(a_r_m1_p3, a_i_m1_p3, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_m1_p3); - square_a_epi16(a_r_m3_p1, a_i_m3_p1, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_m3_p1); - square_a_epi16(a_r_m3_p3, a_i_m3_p3, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_m3_p3); - square_a_epi16(a_r_m1_m1, a_i_m1_m1, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_m1_m1); - square_a_epi16(a_r_m1_m3, a_i_m1_m3, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_m1_m3); - square_a_epi16(a_r_m3_m1, a_i_m3_m1, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_m3_m1); - square_a_epi16(a_r_m3_m3, a_i_m3_m3, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_m3_m3); + a_sq_p1_p1 = square_a_epi16(a_r_p1_p1, a_i_p1_p1, ch_mag_int, SQRT_10_OVER_FOUR); + a_sq_p1_p3 = square_a_epi16(a_r_p1_p3, a_i_p1_p3, ch_mag_int, SQRT_10_OVER_FOUR); + a_sq_p3_p1 = square_a_epi16(a_r_p3_p1, a_i_p3_p1, ch_mag_int, SQRT_10_OVER_FOUR); + a_sq_p3_p3 = square_a_epi16(a_r_p3_p3, a_i_p3_p3, ch_mag_int, SQRT_10_OVER_FOUR); + a_sq_p1_m1 = square_a_epi16(a_r_p1_m1, a_i_p1_m1, ch_mag_int, SQRT_10_OVER_FOUR); + a_sq_p1_m3 = square_a_epi16(a_r_p1_m3, a_i_p1_m3, ch_mag_int, SQRT_10_OVER_FOUR); + a_sq_p3_m1 = square_a_epi16(a_r_p3_m1, a_i_p3_m1, ch_mag_int, SQRT_10_OVER_FOUR); + a_sq_p3_m3 = square_a_epi16(a_r_p3_m3, a_i_p3_m3, ch_mag_int, SQRT_10_OVER_FOUR); + a_sq_m1_p1 = square_a_epi16(a_r_m1_p1, a_i_m1_p1, ch_mag_int, SQRT_10_OVER_FOUR); + a_sq_m1_p3 = square_a_epi16(a_r_m1_p3, a_i_m1_p3, ch_mag_int, SQRT_10_OVER_FOUR); + a_sq_m3_p1 = square_a_epi16(a_r_m3_p1, a_i_m3_p1, ch_mag_int, SQRT_10_OVER_FOUR); + a_sq_m3_p3 = square_a_epi16(a_r_m3_p3, a_i_m3_p3, ch_mag_int, SQRT_10_OVER_FOUR); + a_sq_m1_m1 = square_a_epi16(a_r_m1_m1, a_i_m1_m1, ch_mag_int, SQRT_10_OVER_FOUR); + a_sq_m1_m3 = square_a_epi16(a_r_m1_m3, a_i_m1_m3, ch_mag_int, SQRT_10_OVER_FOUR); + a_sq_m3_m1 = square_a_epi16(a_r_m3_m1, a_i_m3_m1, ch_mag_int, SQRT_10_OVER_FOUR); + a_sq_m3_m3 = square_a_epi16(a_r_m3_m3, a_i_m3_m3, ch_mag_int, SQRT_10_OVER_FOUR); // Computing different multiples of channel norms ch_mag_over_10 = simde_mm_mulhi_epi16(ch_mag_des, ONE_OVER_TWO_SQRT_10); @@ -1350,8 +1347,6 @@ void nr_ulsch_qam16_qam16(c16_t *stream0_in, simde__m256i ch_mag_over_2; simde__m256i ch_mag_9_over_10; - simde__m256i xmm0 __attribute__((aligned(16))); - simde__m256i xmm1 __attribute__((aligned(16))); simde__m256i xmm2 __attribute__((aligned(16))); simde__m256i xmm3 __attribute__((aligned(16))); simde__m256i xmm4 __attribute__((aligned(16))); @@ -1486,9 +1481,6 @@ void nr_ulsch_qam16_qam16(c16_t *stream0_in, simde__m256i y1r __attribute__((aligned(16))); simde__m256i y1i __attribute__((aligned(16))); - simde__m256i tmp_result __attribute__((aligned(16))); - simde__m256i tmp_result2 __attribute__((aligned(16))); - // In one iteration, we deal with 8 REs for (int i = 0; i < length >> 3; i += 2) { @@ -1522,7 +1514,6 @@ void nr_ulsch_qam16_qam16(c16_t *stream0_in, // Rearrange interfering MF output simde_mm256_separate_real_imag_parts(&y1r, &y1i, stream1_256i_in[i], stream1_256i_in[i + 1]); - xmm0 = simde_mm256_setzero_si256(); // ZERO xmm2 = simde_mm256_subs_epi16(rho_rpi_1_1, y1r); // = [Re(rho)+ Im(rho)]/sqrt(10) - y1r psi_r_p1_p1 = simde_mm256_abs_epi16(xmm2); // = |[Re(rho)+ Im(rho)]/sqrt(10) - y1r| @@ -1621,74 +1612,74 @@ void nr_ulsch_qam16_qam16(c16_t *stream0_in, y0_m_3_3 = simde_mm256_subs_epi16(y0r_three_over_sqrt10, y0i_three_over_sqrt10); // Compute optimal interfering symbol magnitude - interference_abs_epi16_256(psi_r_p1_p1, ch_mag_int, a_r_p1_p1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16_256(psi_i_p1_p1, ch_mag_int, a_i_p1_p1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16_256(psi_r_p1_p3, ch_mag_int, a_r_p1_p3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16_256(psi_i_p1_p3, ch_mag_int, a_i_p1_p3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16_256(psi_r_p1_m1, ch_mag_int, a_r_p1_m1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16_256(psi_i_p1_m1, ch_mag_int, a_i_p1_m1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16_256(psi_r_p1_m3, ch_mag_int, a_r_p1_m3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16_256(psi_i_p1_m3, ch_mag_int, a_i_p1_m3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16_256(psi_r_p3_p1, ch_mag_int, a_r_p3_p1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16_256(psi_i_p3_p1, ch_mag_int, a_i_p3_p1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16_256(psi_r_p3_p3, ch_mag_int, a_r_p3_p3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16_256(psi_i_p3_p3, ch_mag_int, a_i_p3_p3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16_256(psi_r_p3_m1, ch_mag_int, a_r_p3_m1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16_256(psi_i_p3_m1, ch_mag_int, a_i_p3_m1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16_256(psi_r_p3_m3, ch_mag_int, a_r_p3_m3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16_256(psi_i_p3_m3, ch_mag_int, a_i_p3_m3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16_256(psi_r_m1_p1, ch_mag_int, a_r_m1_p1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16_256(psi_i_m1_p1, ch_mag_int, a_i_m1_p1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16_256(psi_r_m1_p3, ch_mag_int, a_r_m1_p3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16_256(psi_i_m1_p3, ch_mag_int, a_i_m1_p3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16_256(psi_r_m1_m1, ch_mag_int, a_r_m1_m1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16_256(psi_i_m1_m1, ch_mag_int, a_i_m1_m1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16_256(psi_r_m1_m3, ch_mag_int, a_r_m1_m3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16_256(psi_i_m1_m3, ch_mag_int, a_i_m1_m3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16_256(psi_r_m3_p1, ch_mag_int, a_r_m3_p1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16_256(psi_i_m3_p1, ch_mag_int, a_i_m3_p1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16_256(psi_r_m3_p3, ch_mag_int, a_r_m3_p3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16_256(psi_i_m3_p3, ch_mag_int, a_i_m3_p3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16_256(psi_r_m3_m1, ch_mag_int, a_r_m3_m1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16_256(psi_i_m3_m1, ch_mag_int, a_i_m3_m1, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16_256(psi_r_m3_m3, ch_mag_int, a_r_m3_m3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); - interference_abs_epi16_256(psi_i_m3_m3, ch_mag_int, a_i_m3_m3, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_r_p1_p1 = interference_abs_epi16_256(psi_r_p1_p1, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_i_p1_p1 = interference_abs_epi16_256(psi_i_p1_p1, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_r_p1_p3 = interference_abs_epi16_256(psi_r_p1_p3, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_i_p1_p3 = interference_abs_epi16_256(psi_i_p1_p3, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_r_p1_m1 = interference_abs_epi16_256(psi_r_p1_m1, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_i_p1_m1 = interference_abs_epi16_256(psi_i_p1_m1, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_r_p1_m3 = interference_abs_epi16_256(psi_r_p1_m3, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_i_p1_m3 = interference_abs_epi16_256(psi_i_p1_m3, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_r_p3_p1 = interference_abs_epi16_256(psi_r_p3_p1, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_i_p3_p1 = interference_abs_epi16_256(psi_i_p3_p1, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_r_p3_p3 = interference_abs_epi16_256(psi_r_p3_p3, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_i_p3_p3 = interference_abs_epi16_256(psi_i_p3_p3, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_r_p3_m1 = interference_abs_epi16_256(psi_r_p3_m1, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_i_p3_m1 = interference_abs_epi16_256(psi_i_p3_m1, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_r_p3_m3 = interference_abs_epi16_256(psi_r_p3_m3, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_i_p3_m3 = interference_abs_epi16_256(psi_i_p3_m3, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_r_m1_p1 = interference_abs_epi16_256(psi_r_m1_p1, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_i_m1_p1 = interference_abs_epi16_256(psi_i_m1_p1, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_r_m1_p3 = interference_abs_epi16_256(psi_r_m1_p3, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_i_m1_p3 = interference_abs_epi16_256(psi_i_m1_p3, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_r_m1_m1 = interference_abs_epi16_256(psi_r_m1_m1, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_i_m1_m1 = interference_abs_epi16_256(psi_i_m1_m1, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_r_m1_m3 = interference_abs_epi16_256(psi_r_m1_m3, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_i_m1_m3 = interference_abs_epi16_256(psi_i_m1_m3, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_r_m3_p1 = interference_abs_epi16_256(psi_r_m3_p1, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_i_m3_p1 = interference_abs_epi16_256(psi_i_m3_p1, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_r_m3_p3 = interference_abs_epi16_256(psi_r_m3_p3, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_i_m3_p3 = interference_abs_epi16_256(psi_i_m3_p3, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_r_m3_m1 = interference_abs_epi16_256(psi_r_m3_m1, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_i_m3_m1 = interference_abs_epi16_256(psi_i_m3_m1, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_r_m3_m3 = interference_abs_epi16_256(psi_r_m3_m3, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); + a_i_m3_m3 = interference_abs_epi16_256(psi_i_m3_m3, ch_mag_int, ONE_OVER_SQRT_10_Q15, THREE_OVER_SQRT_10); // Calculation of groups of two terms in the bit metric involving product of psi and interference magnitude - simde__m256i psi_a_p1_p1 = prodsum_psi_a_epi16_256(psi_r_p1_p1, a_r_p1_p1, psi_i_p1_p1, a_i_p1_p1); - simde__m256i psi_a_p1_p3 = prodsum_psi_a_epi16_256(psi_r_p1_p3, a_r_p1_p3, psi_i_p1_p3, a_i_p1_p3); - simde__m256i psi_a_p3_p1 = prodsum_psi_a_epi16_256(psi_r_p3_p1, a_r_p3_p1, psi_i_p3_p1, a_i_p3_p1); - simde__m256i psi_a_p3_p3 = prodsum_psi_a_epi16_256(psi_r_p3_p3, a_r_p3_p3, psi_i_p3_p3, a_i_p3_p3); - simde__m256i psi_a_p1_m1 = prodsum_psi_a_epi16_256(psi_r_p1_m1, a_r_p1_m1, psi_i_p1_m1, a_i_p1_m1); - simde__m256i psi_a_p1_m3 = prodsum_psi_a_epi16_256(psi_r_p1_m3, a_r_p1_m3, psi_i_p1_m3, a_i_p1_m3); - simde__m256i psi_a_p3_m1 = prodsum_psi_a_epi16_256(psi_r_p3_m1, a_r_p3_m1, psi_i_p3_m1, a_i_p3_m1); - simde__m256i psi_a_p3_m3 = prodsum_psi_a_epi16_256(psi_r_p3_m3, a_r_p3_m3, psi_i_p3_m3, a_i_p3_m3); - simde__m256i psi_a_m1_p1 = prodsum_psi_a_epi16_256(psi_r_m1_p1, a_r_m1_p1, psi_i_m1_p1, a_i_m1_p1); - simde__m256i psi_a_m1_p3 = prodsum_psi_a_epi16_256(psi_r_m1_p3, a_r_m1_p3, psi_i_m1_p3, a_i_m1_p3); - simde__m256i psi_a_m3_p1 = prodsum_psi_a_epi16_256(psi_r_m3_p1, a_r_m3_p1, psi_i_m3_p1, a_i_m3_p1); - simde__m256i psi_a_m3_p3 = prodsum_psi_a_epi16_256(psi_r_m3_p3, a_r_m3_p3, psi_i_m3_p3, a_i_m3_p3); - simde__m256i psi_a_m1_m1 = prodsum_psi_a_epi16_256(psi_r_m1_m1, a_r_m1_m1, psi_i_m1_m1, a_i_m1_m1); - simde__m256i psi_a_m1_m3 = prodsum_psi_a_epi16_256(psi_r_m1_m3, a_r_m1_m3, psi_i_m1_m3, a_i_m1_m3); - simde__m256i psi_a_m3_m1 = prodsum_psi_a_epi16_256(psi_r_m3_m1, a_r_m3_m1, psi_i_m3_m1, a_i_m3_m1); - simde__m256i psi_a_m3_m3 = prodsum_psi_a_epi16_256(psi_r_m3_m3, a_r_m3_m3, psi_i_m3_m3, a_i_m3_m3); + psi_a_p1_p1 = prodsum_psi_a_epi16_256(psi_r_p1_p1, a_r_p1_p1, psi_i_p1_p1, a_i_p1_p1); + psi_a_p1_p3 = prodsum_psi_a_epi16_256(psi_r_p1_p3, a_r_p1_p3, psi_i_p1_p3, a_i_p1_p3); + psi_a_p3_p1 = prodsum_psi_a_epi16_256(psi_r_p3_p1, a_r_p3_p1, psi_i_p3_p1, a_i_p3_p1); + psi_a_p3_p3 = prodsum_psi_a_epi16_256(psi_r_p3_p3, a_r_p3_p3, psi_i_p3_p3, a_i_p3_p3); + psi_a_p1_m1 = prodsum_psi_a_epi16_256(psi_r_p1_m1, a_r_p1_m1, psi_i_p1_m1, a_i_p1_m1); + psi_a_p1_m3 = prodsum_psi_a_epi16_256(psi_r_p1_m3, a_r_p1_m3, psi_i_p1_m3, a_i_p1_m3); + psi_a_p3_m1 = prodsum_psi_a_epi16_256(psi_r_p3_m1, a_r_p3_m1, psi_i_p3_m1, a_i_p3_m1); + psi_a_p3_m3 = prodsum_psi_a_epi16_256(psi_r_p3_m3, a_r_p3_m3, psi_i_p3_m3, a_i_p3_m3); + psi_a_m1_p1 = prodsum_psi_a_epi16_256(psi_r_m1_p1, a_r_m1_p1, psi_i_m1_p1, a_i_m1_p1); + psi_a_m1_p3 = prodsum_psi_a_epi16_256(psi_r_m1_p3, a_r_m1_p3, psi_i_m1_p3, a_i_m1_p3); + psi_a_m3_p1 = prodsum_psi_a_epi16_256(psi_r_m3_p1, a_r_m3_p1, psi_i_m3_p1, a_i_m3_p1); + psi_a_m3_p3 = prodsum_psi_a_epi16_256(psi_r_m3_p3, a_r_m3_p3, psi_i_m3_p3, a_i_m3_p3); + psi_a_m1_m1 = prodsum_psi_a_epi16_256(psi_r_m1_m1, a_r_m1_m1, psi_i_m1_m1, a_i_m1_m1); + psi_a_m1_m3 = prodsum_psi_a_epi16_256(psi_r_m1_m3, a_r_m1_m3, psi_i_m1_m3, a_i_m1_m3); + psi_a_m3_m1 = prodsum_psi_a_epi16_256(psi_r_m3_m1, a_r_m3_m1, psi_i_m3_m1, a_i_m3_m1); + psi_a_m3_m3 = prodsum_psi_a_epi16_256(psi_r_m3_m3, a_r_m3_m3, psi_i_m3_m3, a_i_m3_m3); // squared interference magnitude times int. ch. power - square_a_epi16_256(a_r_p1_p1, a_i_p1_p1, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_p1_p1); - square_a_epi16_256(a_r_p1_p3, a_i_p1_p3, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_p1_p3); - square_a_epi16_256(a_r_p3_p1, a_i_p3_p1, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_p3_p1); - square_a_epi16_256(a_r_p3_p3, a_i_p3_p3, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_p3_p3); - square_a_epi16_256(a_r_p1_m1, a_i_p1_m1, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_p1_m1); - square_a_epi16_256(a_r_p1_m3, a_i_p1_m3, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_p1_m3); - square_a_epi16_256(a_r_p3_m1, a_i_p3_m1, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_p3_m1); - square_a_epi16_256(a_r_p3_m3, a_i_p3_m3, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_p3_m3); - square_a_epi16_256(a_r_m1_p1, a_i_m1_p1, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_m1_p1); - square_a_epi16_256(a_r_m1_p3, a_i_m1_p3, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_m1_p3); - square_a_epi16_256(a_r_m3_p1, a_i_m3_p1, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_m3_p1); - square_a_epi16_256(a_r_m3_p3, a_i_m3_p3, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_m3_p3); - square_a_epi16_256(a_r_m1_m1, a_i_m1_m1, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_m1_m1); - square_a_epi16_256(a_r_m1_m3, a_i_m1_m3, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_m1_m3); - square_a_epi16_256(a_r_m3_m1, a_i_m3_m1, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_m3_m1); - square_a_epi16_256(a_r_m3_m3, a_i_m3_m3, ch_mag_int, SQRT_10_OVER_FOUR, a_sq_m3_m3); + a_sq_p1_p1 = square_a_epi16_256(a_r_p1_p1, a_i_p1_p1, ch_mag_int, SQRT_10_OVER_FOUR); + a_sq_p1_p3 = square_a_epi16_256(a_r_p1_p3, a_i_p1_p3, ch_mag_int, SQRT_10_OVER_FOUR); + a_sq_p3_p1 = square_a_epi16_256(a_r_p3_p1, a_i_p3_p1, ch_mag_int, SQRT_10_OVER_FOUR); + a_sq_p3_p3 = square_a_epi16_256(a_r_p3_p3, a_i_p3_p3, ch_mag_int, SQRT_10_OVER_FOUR); + a_sq_p1_m1 = square_a_epi16_256(a_r_p1_m1, a_i_p1_m1, ch_mag_int, SQRT_10_OVER_FOUR); + a_sq_p1_m3 = square_a_epi16_256(a_r_p1_m3, a_i_p1_m3, ch_mag_int, SQRT_10_OVER_FOUR); + a_sq_p3_m1 = square_a_epi16_256(a_r_p3_m1, a_i_p3_m1, ch_mag_int, SQRT_10_OVER_FOUR); + a_sq_p3_m3 = square_a_epi16_256(a_r_p3_m3, a_i_p3_m3, ch_mag_int, SQRT_10_OVER_FOUR); + a_sq_m1_p1 = square_a_epi16_256(a_r_m1_p1, a_i_m1_p1, ch_mag_int, SQRT_10_OVER_FOUR); + a_sq_m1_p3 = square_a_epi16_256(a_r_m1_p3, a_i_m1_p3, ch_mag_int, SQRT_10_OVER_FOUR); + a_sq_m3_p1 = square_a_epi16_256(a_r_m3_p1, a_i_m3_p1, ch_mag_int, SQRT_10_OVER_FOUR); + a_sq_m3_p3 = square_a_epi16_256(a_r_m3_p3, a_i_m3_p3, ch_mag_int, SQRT_10_OVER_FOUR); + a_sq_m1_m1 = square_a_epi16_256(a_r_m1_m1, a_i_m1_m1, ch_mag_int, SQRT_10_OVER_FOUR); + a_sq_m1_m3 = square_a_epi16_256(a_r_m1_m3, a_i_m1_m3, ch_mag_int, SQRT_10_OVER_FOUR); + a_sq_m3_m1 = square_a_epi16_256(a_r_m3_m1, a_i_m3_m1, ch_mag_int, SQRT_10_OVER_FOUR); + a_sq_m3_m3 = square_a_epi16_256(a_r_m3_m3, a_i_m3_m3, ch_mag_int, SQRT_10_OVER_FOUR); // Computing different multiples of channel norms ch_mag_over_10 = simde_mm256_mulhi_epi16(ch_mag_des, ONE_OVER_TWO_SQRT_10); @@ -2352,7 +2343,6 @@ void nr_ulsch_qam64_qam64(c16_t *stream0_in, ch_mag_int_with_sigma2 = simde_mm_srai_epi16(ch_mag_int, 1); // *2 two_ch_mag_int_with_sigma2 = ch_mag_int; // *4 three_ch_mag_int_with_sigma2 = simde_mm_adds_epi16(ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2); // *6 - simde__m128i tmp_result, tmp_result2, tmp_result3, tmp_result4; simde__m128i a_r_p7_p7 = interference_abs_64qam_epi16(psi_r_p7_p7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, @@ -4735,7 +4725,6 @@ void nr_ulsch_qam64_qam64(c16_t *stream0_in, ch_mag_int_with_sigma2 = simde_mm256_srai_epi16(ch_mag_int, 1); // *2 two_ch_mag_int_with_sigma2 = ch_mag_int; // *4 three_ch_mag_int_with_sigma2 = simde_mm256_adds_epi16(ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2); // *6 - simde__m256i tmp_result, tmp_result2, tmp_result3, tmp_result4; simde__m256i a_r_p7_p7 = interference_abs_64qam_epi16_256(psi_r_p7_p7, ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, From b46479889d8232e8a60845fadd8545d3f5f80781 Mon Sep 17 00:00:00 2001 From: Quency Date: Thu, 13 Jul 2023 00:39:38 +0200 Subject: [PATCH 13/47] misc / Reorder inlines and add architecture guard --- .../NR_TRANSPORT/nr_ulsch_llr_computation.c | 173 +++++++++--------- 1 file changed, 89 insertions(+), 84 deletions(-) diff --git a/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c b/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c index 430e66041e..53aa602744 100644 --- a/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c +++ b/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c @@ -574,10 +574,10 @@ void nr_ulsch_qpsk_qpsk(c16_t *stream0_in, c16_t *stream1_in, c16_t *stream0_out } -static const int16_t ones[8] __attribute__((aligned(16))) = {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff}; -static const int16_t ones256[16] __attribute__((aligned(32))) = {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, - 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff}; +#ifdef USE_128BIT + +static const int16_t ones[8] __attribute__((aligned(16))) = {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff}; // calculate interference magnitude // tmp_result = ones in shorts corr. to interval 2<=x<=4, tmp_result2 interval < 2, tmp_result3 interval 4 Date: Thu, 13 Jul 2023 00:57:55 +0200 Subject: [PATCH 14/47] feat / SISO: Use 128/256 SIMDe for ARM64/x86 --- .../NR_TRANSPORT/nr_ulsch_llr_computation.c | 169 +++++++++++++++++- 1 file changed, 164 insertions(+), 5 deletions(-) diff --git a/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c b/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c index 53aa602744..bebd50601b 100644 --- a/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c +++ b/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c @@ -66,6 +66,36 @@ void nr_ulsch_16qam_llr(int32_t *rxdataF_comp, uint32_t nb_re, uint8_t symbol) { +#ifdef USE_128BIT + simde__m128i *rxF = (simde__m128i*)rxdataF_comp; + simde__m128i *ch_mag; + simde__m128i llr128[2]; + register simde__m128i xmm0; + simde__m64 *llr64 = (simde__m64*) ulsch_llr; + int i; + int nb_rb = nb_re / NR_NB_SC_PER_RB; + int off = ((nb_rb&1) == 1)? 4:0; + + ch_mag = (simde__m128i*)&ul_ch_mag[(symbol*(off+(nb_rb*12)))]; + nb_re >>= 2; // length in quad words (4 REs) + nb_re += ((nb_re&3) == 0 ? 0 : 1); + + // Each iteration does 4 RE (gives 16 16bit-llrs) + for (i=0; i |y_R|, registers of odd index in xmm0-> |y_I| + xmm0 = simde_mm_subs_epi16(ch_mag[i],xmm0); // registers of even index in xmm0-> |y_R|-|h|^2, registers of odd index in xmm0-> |y_I|-|h|^2 + + llr128[0] = simde_mm_unpacklo_epi32(rxF[i],xmm0); // llr128[0] contains the llrs of the 1st,2nd,5th and 6th REs + llr128[1] = simde_mm_unpackhi_epi32(rxF[i],xmm0); // llr128[1] contains the llrs of the 3rd, 4th, 7th and 8th REs + + llr64[0] = (simde__m64)simde_mm_extract_epi64(llr128[0], 0); // llr32[0] low 16 bits-> y_R, high 16 bits-> y_I + llr64[1] = (simde__m64)simde_mm_extract_epi64(llr128[0], 1); // llr32[2] low 16 bits-> y_R, high 16 bits-> y_I + llr64[2] = (simde__m64)simde_mm_extract_epi64(llr128[1], 0); // llr32[4] low 16 bits-> y_R, high 16 bits-> y_I + llr64[3] = (simde__m64)simde_mm_extract_epi64(llr128[1], 1); // llr32[6] low 16 bits-> y_R, high 16 bits-> y_I + + llr64 += 4; + } +#else simde__m256i *rxF_256 = (simde__m256i*)rxdataF_comp; simde__m256i *ch_mag = (simde__m256i*)ul_ch_mag; int64_t *llr_64 = (int64_t*)ulsch_llr; @@ -91,6 +121,8 @@ void nr_ulsch_16qam_llr(int32_t *rxdataF_comp, *llr_64++ = simde_mm256_extract_epi64(xmm2, 2); *llr_64++ = simde_mm256_extract_epi64(xmm2, 3); } +#endif + simde_mm_empty(); } //---------------------------------------------------------------------------------------------- @@ -104,6 +136,38 @@ void nr_ulsch_64qam_llr(int32_t *rxdataF_comp, uint32_t nb_re, uint8_t symbol) { +#ifdef USE_128BIT + int nb_rb = nb_re / NR_NB_SC_PER_RB; + int off = ((nb_rb&1) == 1)? 4:0; + + simde__m128i *rxF = (simde__m128i*)rxdataF_comp; + simde__m128i *ch_mag,*ch_magb; + register simde__m128i xmm0,xmm1,xmm2; + int i; + ch_mag = (simde__m128i*)&ul_ch_mag[(symbol*(off+(nb_rb*12)))]; + ch_magb = (simde__m128i*)&ul_ch_magb[(symbol*(off+(nb_rb*12)))]; + + nb_re = nb_re>>2; // length in 128-bit words (4 REs) + nb_re += ((nb_re&3) == 0 ? 0 : 1); + simde__m64 *llr64 = (simde__m64 *) ulsch_llr; + + // Each iteration does 4 RE (gives 24 16bit-llrs) + for (i=0; i> 2; // length in 128-bit words (4 REs) + + for (int i=0; i |y_R|, registers of odd index in xmm0-> |y_I| + xmm0 = simde_mm_subs_epi16(ch_mag[i], xmm0); // registers of even index in xmm0-> |y_R|-|h|^2, registers of odd index in xmm0-> |y_I|-|h|^2 + xmm1 = simde_mm_abs_epi16(xmm0); + xmm1 = simde_mm_subs_epi16(ch_magb[i], xmm1); // contains 8 LLRs + xmm2 = simde_mm_abs_epi16(xmm1); + xmm2 = simde_mm_subs_epi16(ch_magc[i], xmm2); // contains 8 LLRs + // rxF[i] A0 A1 A2 A3 + // xmm0 B0 B1 B2 B3 + // xmm1 C0 C1 C2 C3 + // xmm2 D0 D1 D2 D3 + xmm3 = simde_mm_unpacklo_epi32(rxF[i], xmm0); // A0 B0 A1 B1 + xmm4 = simde_mm_unpackhi_epi32(rxF[i], xmm0); // A2 B2 A3 B3 + xmm5 = simde_mm_unpacklo_epi32(xmm1, xmm2); // C0 D0 C1 D1 + xmm6 = simde_mm_unpackhi_epi32(xmm1, xmm2); // C2 D2 C3 D3 + + llr128[0] = simde_mm_unpacklo_epi64(xmm3,xmm5); // A0 B0 C0 D0 + llr128[1] = simde_mm_unpackhi_epi64(xmm3,xmm5); // A1 B1 C1 D1 + llr128[2] = simde_mm_unpacklo_epi64(xmm4,xmm6); // A2 B2 C2 D2 + llr128[3] = simde_mm_unpackhi_epi64(xmm4,xmm6); // A3 B3 C3 D3 + llr128+=4; + } + + if (len_mod4) { + printf("len_mod4=%d\n", len_mod4); + int nb_re64 = nb_re >> 1; + simde__m64 *llr64 = (simde__m64 *)llr128; + simde__m64 xmm0,xmm1,xmm2; + simde__m64 *rxF = (simde__m64*)rxdataF_comp; + simde__m64 *ch_mag = (simde__m64*)&ul_ch_mag[(symbol*(off+(nb_rb*12)))]; + simde__m64 *ch_magb = (simde__m64*)&ul_ch_magb[(symbol*(off+(nb_rb*12)))]; + simde__m64 *ch_magc = (simde__m64*)&ul_ch_magc[(symbol*(off+(nb_rb*12)))]; + + xmm0 = simde_mm_abs_pi16(rxF[nb_re64-1]); // registers of even index in xmm0-> |y_R|, registers of odd index in xmm0-> |y_I| + xmm0 = simde_mm_subs_pi16(ch_mag[nb_re-1],xmm0); // registers of even index in xmm0-> |y_R|-|h|^2, registers of odd index in xmm0-> |y_I|-|h|^2 + // xmmtmpD2 contains 4 LLRs + xmm1 = simde_mm_abs_pi16(xmm0); + xmm1 = simde_mm_subs_pi16(ch_magb[nb_re64-1],xmm1); // contains 4 LLRs + xmm2 = simde_mm_abs_pi16(xmm1); + xmm2 = simde_mm_subs_pi16(ch_magc[nb_re64-1],xmm2); // contains 4 LLRs + // rxF[i] A0 A1 + // xmm0 B0 B1 + // xmm1 C0 C1 + // xmm2 D0 D1 + llr64[0] = simde_m_punpckldq(rxF[nb_re64-1],xmm0); // A0 B0 + llr64[2] = simde_m_punpckhdq(rxF[nb_re64-1],xmm0); // A1 B1 + llr64[1] = simde_m_punpckldq(xmm1,xmm2); // C0 D0 + llr64[3] = simde_m_punpckhdq(xmm1,xmm2); // C1 D1 + } +#else simde__m256i *rxF = (simde__m256i*)rxdataF_comp; simde__m256i xmm0,xmm1,xmm2,xmm3,xmm4,xmm5,xmm6; simde__m256i *llr256=(simde__m256i*)ulsch_llr; @@ -198,6 +328,8 @@ void nr_ulsch_256qam_llr(int32_t *rxdataF_comp, *llr256++ = simde_mm256_permute2x128_si256(xmm0, xmm1, 0x31); // A4 B4 C4 D4 A5 B5 C5 D5 *llr256++ = simde_mm256_permute2x128_si256(xmm2, xmm3, 0x31); // A6 B6 C6 D6 A7 B7 C7 D7 } +#endif + simde_mm_empty(); } void nr_ulsch_compute_llr(int32_t *rxdataF_comp, @@ -568,9 +700,7 @@ void nr_ulsch_qpsk_qpsk(c16_t *stream0_in, c16_t *stream1_in, c16_t *stream0_out } } #endif - simde_mm_empty(); - simde_m_empty(); } @@ -1875,7 +2005,6 @@ void nr_ulsch_qam16_qam16(c16_t *stream0_in, } #endif simde_mm_empty(); - simde_m_empty(); } /* @@ -6664,9 +6793,7 @@ void nr_ulsch_qam64_qam64(c16_t *stream0_in, } } #endif - simde_mm_empty(); - simde_m_empty(); } static void nr_ulsch_shift_llr(int16_t **llr_layers, uint32_t nb_re, uint32_t rxdataF_ext_offset, uint8_t mod_order, int shift) @@ -6692,3 +6819,35 @@ static void nr_ulsch_shift_llr(int16_t **llr_layers, uint32_t nb_re, uint32_t rx llr_layers1[i] = simde_mm_srai_epi16(llr_layers1[i], shift); } } + +void nr_ulsch_compute_ML_llr(NR_gNB_PUSCH *pusch_vars, + uint32_t symbol, + c16_t* rxdataF_comp0, + c16_t* rxdataF_comp1, + c16_t* ul_ch_mag0, + c16_t* ul_ch_mag1, + c16_t* llr_layers0, + c16_t* llr_layers1, + c16_t* rho0, + c16_t* rho1, + uint32_t nb_re, + uint8_t mod_order) +{ + switch (mod_order) { + case 2: + nr_ulsch_qpsk_qpsk(rxdataF_comp0, rxdataF_comp1, llr_layers0, rho0, nb_re); + nr_ulsch_qpsk_qpsk(rxdataF_comp1, rxdataF_comp0, llr_layers1, rho1, nb_re); + nr_ulsch_shift_llr(pusch_vars->llr_layers, nb_re, pusch_vars->llr_offset[symbol] >> 1, 2, 4); + break; + case 4: + nr_ulsch_qam16_qam16(rxdataF_comp0, rxdataF_comp1, ul_ch_mag0, ul_ch_mag1, llr_layers0, rho0, nb_re); + nr_ulsch_qam16_qam16(rxdataF_comp1, rxdataF_comp0, ul_ch_mag1, ul_ch_mag0, llr_layers1, rho1, nb_re); + break; + case 6: + nr_ulsch_qam64_qam64(rxdataF_comp0, rxdataF_comp1, ul_ch_mag0, ul_ch_mag1, llr_layers0, rho0, nb_re); + nr_ulsch_qam64_qam64(rxdataF_comp1, rxdataF_comp0, ul_ch_mag1, ul_ch_mag0, llr_layers1, rho1, nb_re); + break; + default: + AssertFatal(1 == 0, "nr_ulsch_compute_llr: invalid Qm value, Qm = %d\n", mod_order); + } +} From 526363dfad608a8e3305436c4acfcbcdc06150d1 Mon Sep 17 00:00:00 2001 From: Tsung-Yu Chan Date: Thu, 20 Jul 2023 14:42:22 +0200 Subject: [PATCH 15/47] fix / add the static for max_epi16 --- openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c b/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c index bebd50601b..742630c672 100644 --- a/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c +++ b/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c @@ -792,7 +792,7 @@ static inline simde__m128i square_a_64qam_epi16(simde__m128i a_r, simde__m128i a return simde_mm_adds_epi16(tmp_result, tmp_result2); } -simde__m128i max_epi16(simde__m128i m0, simde__m128i m1, simde__m128i m2, simde__m128i m3, simde__m128i m4, simde__m128i m5, simde__m128i m6, simde__m128i m7) +static inline simde__m128i max_epi16(simde__m128i m0, simde__m128i m1, simde__m128i m2, simde__m128i m3, simde__m128i m4, simde__m128i m5, simde__m128i m6, simde__m128i m7) { simde__m128i a0 = simde_mm_max_epi16(m0, m1); simde__m128i a1 = simde_mm_max_epi16(m2, m3); @@ -891,7 +891,7 @@ static inline simde__m256i square_a_64qam_epi16_256(simde__m256i a_r, simde__m25 return simde_mm256_adds_epi16(tmp_result, tmp_result2); } -simde__m256i max_epi16_256(simde__m256i m0, simde__m256i m1, simde__m256i m2, simde__m256i m3, simde__m256i m4, simde__m256i m5, simde__m256i m6, simde__m256i m7) +static inline simde__m256i max_epi16_256(simde__m256i m0, simde__m256i m1, simde__m256i m2, simde__m256i m3, simde__m256i m4, simde__m256i m5, simde__m256i m6, simde__m256i m7) { simde__m256i a0 = simde_mm256_max_epi16(m0, m1); simde__m256i a1 = simde_mm256_max_epi16(m2, m3); From 465fc55e20436d75c803f2df353f79ee8f2ab3b6 Mon Sep 17 00:00:00 2001 From: Quency Lin Date: Thu, 7 Sep 2023 10:22:40 +0200 Subject: [PATCH 16/47] Refactor: Make qam16_qam16 more compact Use local arrays and for-loop to replace duplicated statements. For reference, here is the table of index v.s. old local variable suffix. 0 p1_p1 0 rpi_1_1 1 p1_p3 1 rpi_1_3 2 p3_p1 2 rpi_3_1 3 p3_p3 3 rpi_3_3 4 p1_m1 4 rmi_1_1 5 p1_m3 5 rmi_1_3 6 p3_m1 6 rmi_3_1 7 p3_m3 7 rmi_3_3 8 m1_p1 9 m1_p3 10 m3_p1 11 m3_p3 12 m1_m1 13 m1_m3 14 m3_m1 15 m3_m3 --- .../NR_TRANSPORT/nr_ulsch_llr_computation.c | 982 +++--------------- 1 file changed, 173 insertions(+), 809 deletions(-) diff --git a/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c b/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c index 742630c672..50a2da40fb 100644 --- a/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c +++ b/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c @@ -961,125 +961,14 @@ void nr_ulsch_qam16_qam16(c16_t *stream0_in, simde__m128i rho_rpi __attribute__((aligned(16))); simde__m128i rho_rmi __attribute__((aligned(16))); - simde__m128i rho_rpi_1_1 __attribute__((aligned(16))); - simde__m128i rho_rpi_1_3 __attribute__((aligned(16))); - simde__m128i rho_rpi_3_1 __attribute__((aligned(16))); - simde__m128i rho_rpi_3_3 __attribute__((aligned(16))); - simde__m128i rho_rmi_1_1 __attribute__((aligned(16))); - simde__m128i rho_rmi_1_3 __attribute__((aligned(16))); - simde__m128i rho_rmi_3_1 __attribute__((aligned(16))); - simde__m128i rho_rmi_3_3 __attribute__((aligned(16))); - - simde__m128i psi_r_m3_m3 __attribute__((aligned(16))); - simde__m128i psi_r_m3_m1 __attribute__((aligned(16))); - simde__m128i psi_r_m3_p1 __attribute__((aligned(16))); - simde__m128i psi_r_m3_p3 __attribute__((aligned(16))); - simde__m128i psi_r_m1_m3 __attribute__((aligned(16))); - simde__m128i psi_r_m1_m1 __attribute__((aligned(16))); - simde__m128i psi_r_m1_p1 __attribute__((aligned(16))); - simde__m128i psi_r_m1_p3 __attribute__((aligned(16))); - simde__m128i psi_r_p1_m3 __attribute__((aligned(16))); - simde__m128i psi_r_p1_m1 __attribute__((aligned(16))); - simde__m128i psi_r_p1_p1 __attribute__((aligned(16))); - simde__m128i psi_r_p1_p3 __attribute__((aligned(16))); - simde__m128i psi_r_p3_m3 __attribute__((aligned(16))); - simde__m128i psi_r_p3_m1 __attribute__((aligned(16))); - simde__m128i psi_r_p3_p1 __attribute__((aligned(16))); - simde__m128i psi_r_p3_p3 __attribute__((aligned(16))); - - simde__m128i psi_i_m3_m3 __attribute__((aligned(16))); - simde__m128i psi_i_m3_m1 __attribute__((aligned(16))); - simde__m128i psi_i_m3_p1 __attribute__((aligned(16))); - simde__m128i psi_i_m3_p3 __attribute__((aligned(16))); - simde__m128i psi_i_m1_m3 __attribute__((aligned(16))); - simde__m128i psi_i_m1_m1 __attribute__((aligned(16))); - simde__m128i psi_i_m1_p1 __attribute__((aligned(16))); - simde__m128i psi_i_m1_p3 __attribute__((aligned(16))); - simde__m128i psi_i_p1_m3 __attribute__((aligned(16))); - simde__m128i psi_i_p1_m1 __attribute__((aligned(16))); - simde__m128i psi_i_p1_p1 __attribute__((aligned(16))); - simde__m128i psi_i_p1_p3 __attribute__((aligned(16))); - simde__m128i psi_i_p3_m3 __attribute__((aligned(16))); - simde__m128i psi_i_p3_m1 __attribute__((aligned(16))); - simde__m128i psi_i_p3_p1 __attribute__((aligned(16))); - simde__m128i psi_i_p3_p3 __attribute__((aligned(16))); - - simde__m128i a_r_m3_m3 __attribute__((aligned(16))); - simde__m128i a_r_m3_m1 __attribute__((aligned(16))); - simde__m128i a_r_m3_p1 __attribute__((aligned(16))); - simde__m128i a_r_m3_p3 __attribute__((aligned(16))); - simde__m128i a_r_m1_m3 __attribute__((aligned(16))); - simde__m128i a_r_m1_m1 __attribute__((aligned(16))); - simde__m128i a_r_m1_p1 __attribute__((aligned(16))); - simde__m128i a_r_m1_p3 __attribute__((aligned(16))); - simde__m128i a_r_p1_m3 __attribute__((aligned(16))); - simde__m128i a_r_p1_m1 __attribute__((aligned(16))); - simde__m128i a_r_p1_p1 __attribute__((aligned(16))); - simde__m128i a_r_p1_p3 __attribute__((aligned(16))); - simde__m128i a_r_p3_m3 __attribute__((aligned(16))); - simde__m128i a_r_p3_m1 __attribute__((aligned(16))); - simde__m128i a_r_p3_p1 __attribute__((aligned(16))); - simde__m128i a_r_p3_p3 __attribute__((aligned(16))); - - simde__m128i a_i_m3_m3 __attribute__((aligned(16))); - simde__m128i a_i_m3_m1 __attribute__((aligned(16))); - simde__m128i a_i_m3_p1 __attribute__((aligned(16))); - simde__m128i a_i_m3_p3 __attribute__((aligned(16))); - simde__m128i a_i_m1_m3 __attribute__((aligned(16))); - simde__m128i a_i_m1_m1 __attribute__((aligned(16))); - simde__m128i a_i_m1_p1 __attribute__((aligned(16))); - simde__m128i a_i_m1_p3 __attribute__((aligned(16))); - simde__m128i a_i_p1_m3 __attribute__((aligned(16))); - simde__m128i a_i_p1_m1 __attribute__((aligned(16))); - simde__m128i a_i_p1_p1 __attribute__((aligned(16))); - simde__m128i a_i_p1_p3 __attribute__((aligned(16))); - simde__m128i a_i_p3_m3 __attribute__((aligned(16))); - simde__m128i a_i_p3_m1 __attribute__((aligned(16))); - simde__m128i a_i_p3_p1 __attribute__((aligned(16))); - simde__m128i a_i_p3_p3 __attribute__((aligned(16))); - - simde__m128i psi_a_m3_m3 __attribute__((aligned(16))); - simde__m128i psi_a_m3_m1 __attribute__((aligned(16))); - simde__m128i psi_a_m3_p1 __attribute__((aligned(16))); - simde__m128i psi_a_m3_p3 __attribute__((aligned(16))); - simde__m128i psi_a_m1_m3 __attribute__((aligned(16))); - simde__m128i psi_a_m1_m1 __attribute__((aligned(16))); - simde__m128i psi_a_m1_p1 __attribute__((aligned(16))); - simde__m128i psi_a_m1_p3 __attribute__((aligned(16))); - simde__m128i psi_a_p1_m3 __attribute__((aligned(16))); - simde__m128i psi_a_p1_m1 __attribute__((aligned(16))); - simde__m128i psi_a_p1_p1 __attribute__((aligned(16))); - simde__m128i psi_a_p1_p3 __attribute__((aligned(16))); - simde__m128i psi_a_p3_m3 __attribute__((aligned(16))); - simde__m128i psi_a_p3_m1 __attribute__((aligned(16))); - simde__m128i psi_a_p3_p1 __attribute__((aligned(16))); - simde__m128i psi_a_p3_p3 __attribute__((aligned(16))); - - simde__m128i a_sq_m3_m3 __attribute__((aligned(16))); - simde__m128i a_sq_m3_m1 __attribute__((aligned(16))); - simde__m128i a_sq_m3_p1 __attribute__((aligned(16))); - simde__m128i a_sq_m3_p3 __attribute__((aligned(16))); - simde__m128i a_sq_m1_m3 __attribute__((aligned(16))); - simde__m128i a_sq_m1_m1 __attribute__((aligned(16))); - simde__m128i a_sq_m1_p1 __attribute__((aligned(16))); - simde__m128i a_sq_m1_p3 __attribute__((aligned(16))); - simde__m128i a_sq_p1_m3 __attribute__((aligned(16))); - simde__m128i a_sq_p1_m1 __attribute__((aligned(16))); - simde__m128i a_sq_p1_p1 __attribute__((aligned(16))); - simde__m128i a_sq_p1_p3 __attribute__((aligned(16))); - simde__m128i a_sq_p3_m3 __attribute__((aligned(16))); - simde__m128i a_sq_p3_m1 __attribute__((aligned(16))); - simde__m128i a_sq_p3_p1 __attribute__((aligned(16))); - simde__m128i a_sq_p3_p3 __attribute__((aligned(16))); - - simde__m128i y0_p_1_1 __attribute__((aligned(16))); - simde__m128i y0_p_1_3 __attribute__((aligned(16))); - simde__m128i y0_p_3_1 __attribute__((aligned(16))); - simde__m128i y0_p_3_3 __attribute__((aligned(16))); - simde__m128i y0_m_1_1 __attribute__((aligned(16))); - simde__m128i y0_m_1_3 __attribute__((aligned(16))); - simde__m128i y0_m_3_1 __attribute__((aligned(16))); - simde__m128i y0_m_3_3 __attribute__((aligned(16))); + simde__m128i rho_rs[8] __attribute__((aligned(16))); + simde__m128i psi_rs[16] __attribute__((aligned(16))); + simde__m128i psi_is[16] __attribute__((aligned(16))); + simde__m128i a_rs[16] __attribute__((aligned(16))); + simde__m128i a_is[16] __attribute__((aligned(16))); + simde__m128i psi_as[16] __attribute__((aligned(16))); + simde__m128i a_sqs[16] __attribute__((aligned(16))); + simde__m128i y0_s[8] __attribute__((aligned(16))); simde__m128i y0r __attribute__((aligned(16))); simde__m128i y0i __attribute__((aligned(16))); @@ -1095,96 +984,42 @@ void nr_ulsch_qam16_qam16(c16_t *stream0_in, rho_rmi = simde_mm_subs_epi16(xmm2, xmm3); // rho* = Re(rho) - Im(rho) // Compute the different rhos - rho_rpi_1_1 = simde_mm_mulhi_epi16(rho_rpi, ONE_OVER_SQRT_10); - rho_rmi_1_1 = simde_mm_mulhi_epi16(rho_rmi, ONE_OVER_SQRT_10); - rho_rpi_3_3 = simde_mm_mulhi_epi16(rho_rpi, THREE_OVER_SQRT_10); - rho_rmi_3_3 = simde_mm_mulhi_epi16(rho_rmi, THREE_OVER_SQRT_10); - rho_rpi_3_3 = simde_mm_slli_epi16(rho_rpi_3_3, 1); - rho_rmi_3_3 = simde_mm_slli_epi16(rho_rmi_3_3, 1); + rho_rs[0] = simde_mm_mulhi_epi16(rho_rpi, ONE_OVER_SQRT_10); + rho_rs[4] = simde_mm_mulhi_epi16(rho_rmi, ONE_OVER_SQRT_10); + rho_rs[3] = simde_mm_slli_epi16(simde_mm_mulhi_epi16(rho_rpi, THREE_OVER_SQRT_10), 1); + rho_rs[7] = simde_mm_slli_epi16(simde_mm_mulhi_epi16(rho_rmi, THREE_OVER_SQRT_10), 1); xmm4 = simde_mm_mulhi_epi16(xmm2, ONE_OVER_SQRT_10); // Re(rho) xmm5 = simde_mm_mulhi_epi16(xmm3, THREE_OVER_SQRT_10); // Im(rho) xmm5 = simde_mm_slli_epi16(xmm5, 1); - rho_rpi_1_3 = simde_mm_adds_epi16(xmm4, xmm5); - rho_rmi_1_3 = simde_mm_subs_epi16(xmm4, xmm5); + rho_rs[1] = simde_mm_adds_epi16(xmm4, xmm5); + rho_rs[5] = simde_mm_subs_epi16(xmm4, xmm5); xmm6 = simde_mm_mulhi_epi16(xmm2, THREE_OVER_SQRT_10); // Re(rho) xmm7 = simde_mm_mulhi_epi16(xmm3, ONE_OVER_SQRT_10); // Im(rho) xmm6 = simde_mm_slli_epi16(xmm6, 1); - rho_rpi_3_1 = simde_mm_adds_epi16(xmm6, xmm7); - rho_rmi_3_1 = simde_mm_subs_epi16(xmm6, xmm7); + rho_rs[2] = simde_mm_adds_epi16(xmm6, xmm7); + rho_rs[6] = simde_mm_subs_epi16(xmm6, xmm7); // Rearrange interfering MF output simde_mm128_separate_real_imag_parts(&y1r, &y1i, stream1_128i_in[i], stream1_128i_in[i + 1]); - xmm0 = simde_mm_setzero_si128(); // ZERO - xmm2 = simde_mm_subs_epi16(rho_rpi_1_1, y1r); // = [Re(rho)+ Im(rho)]/sqrt(10) - y1r - psi_r_p1_p1 = simde_mm_abs_epi16(xmm2); // = |[Re(rho)+ Im(rho)]/sqrt(10) - y1r| - - xmm2 = simde_mm_subs_epi16(rho_rmi_1_1, y1r); - psi_r_p1_m1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_1_1, y1i); - psi_i_p1_p1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_1_3, y1r); - psi_r_p1_p3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_1_3, y1r); - psi_r_p1_m3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_3_1, y1i); - psi_i_p1_p3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_3_1, y1r); - psi_r_p3_p1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_3_1, y1r); - psi_r_p3_m1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_1_3, y1i); - psi_i_p3_p1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_3_3, y1r); - psi_r_p3_p3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_3_3, y1r); - psi_r_p3_m3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_3_3, y1i); - psi_i_p3_p3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_1_1, y1i); - psi_i_m1_p1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_3_1, y1i); - psi_i_m1_p3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_1_3, y1i); - psi_i_m3_p1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_3_3, y1i); - psi_i_m3_p3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_1_1, y1i); - psi_i_p1_m1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_3_1, y1i); - psi_i_p1_m3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_1_3, y1i); - psi_i_p3_m1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_3_3, y1i); - psi_i_p3_m3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_1_1, y1r); - psi_r_m1_m1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_1_3, y1r); - psi_r_m1_m3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_3_1, y1r); - psi_r_m3_m1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_3_3, y1r); - psi_r_m3_m3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(y1r, rho_rmi_1_1); - psi_r_m1_p1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(y1r, rho_rmi_1_3); - psi_r_m1_p3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(y1i, rho_rmi_1_1); - psi_i_m1_m1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(y1i, rho_rmi_3_1); - psi_i_m1_m3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(y1r, rho_rmi_3_1); - psi_r_m3_p1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(y1r, rho_rmi_3_3); - psi_r_m3_p3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(y1i, rho_rmi_1_3); - psi_i_m3_m1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(y1i, rho_rmi_3_3); - psi_i_m3_m3 = simde_mm_abs_epi16(xmm2); + // | [Re(rho)+ Im(rho)]/sqrt(10) - y1r | + for(int j=0; j<8; j++){ // psi_rs[0~7], rho_rs[0~7] + psi_rs[j] = simde_mm_abs_epi16( simde_mm_subs_epi16(rho_rs[j], y1r) ); + } + for(int j=8; j<16; j++){ // psi_rs[8~16], rho_rs[4,5,6,7,0,1,2,3] + psi_rs[j] = simde_mm_abs_epi16( simde_mm_adds_epi16(rho_rs[(j-4) & 7], y1r) ); + } + const uint8_t rho_rs_indexes[16] = {4,6,5,7,0,2,1,3,0,2,1,3,4,6,5,7}; + for(int k=0; k<16; k+=8){ // psi_is[0~15], sub(rho_rs[4,6,5,7]), add(rho_rs[0,2,1,3]), sub(rho_rs[0,2,1,3]), add(rho_rs[4,6,5,7]) + for(int j=k; j Date: Fri, 8 Sep 2023 11:08:53 +0200 Subject: [PATCH 17/47] Refactor: Make qam64_qam64 more compact Use local arrays and for-loop to replace duplicated statements. For reference, here is the table of index v.s. old local variable qam64 qam64 psi_r_, psi_i_, a_r_, a_i_, psi_a_, a_sq_, bit_met_ 0 p7_p7 16 p3_p7 32 m1_p7 48 m5_p7 1 p7_p5 17 p3_p5 33 m1_p5 49 m5_p5 2 p7_p3 18 p3_p3 34 m1_p3 50 m5_p3 3 p7_p1 19 p3_p1 35 m1_p1 51 m5_p1 4 p7_m1 20 p3_m1 36 m1_m1 52 m5_m1 5 p7_m3 21 p3_m3 37 m1_m3 53 m5_m3 6 p7_m5 22 p3_m5 38 m1_m5 54 m5_m5 7 p7_m7 23 p3_m7 39 m1_m7 55 m5_m7 8 p5_p7 24 p1_p7 40 m3_p7 56 m7_p7 9 p5_p5 25 p1_p5 41 m3_p5 57 m7_p5 10 p5_p3 26 p1_p3 42 m3_p3 58 m7_p3 11 p5_p1 27 p1_p1 43 m3_p1 59 m7_p1 12 p5_m1 28 p1_m1 44 m3_m1 60 m7_m1 13 p5_m3 29 p1_m3 45 m3_m3 61 m7_m3 14 p5_m5 30 p1_m5 46 m3_m5 62 m7_m5 15 p5_m7 31 p1_m7 47 m3_m7 63 m7_m7 y0 0 y0_p_7_7 16 y0_p_3_7 1 y0_p_7_5 17 y0_p_3_5 2 y0_p_7_3 18 y0_p_3_3 3 y0_p_7_1 19 y0_p_3_1 4 y0_m_7_1 20 y0_m_3_1 5 y0_m_7_3 21 y0_m_3_3 6 y0_m_7_5 22 y0_m_3_5 7 y0_m_7_7 23 y0_m_3_7 8 y0_p_5_7 24 y0_p_1_7 9 y0_p_5_5 25 y0_p_1_5 10 y0_p_5_3 26 y0_p_1_3 11 y0_p_5_1 27 y0_p_1_1 12 y0_m_5_1 28 y0_m_1_1 13 y0_m_5_3 29 y0_m_1_3 14 y0_m_5_5 30 y0_m_1_5 15 y0_m_5_7 31 y0_m_1_7 rho_r 0 pi_7_7 16 pi_3_7 1 pi_7_5 17 pi_3_5 2 pi_7_3 18 pi_3_3 3 pi_7_1 19 pi_3_1 4 mi_7_1 20 mi_3_1 5 mi_7_3 21 mi_3_3 6 mi_7_5 22 mi_3_5 7 mi_7_7 23 mi_3_7 8 pi_5_7 24 pi_1_7 9 pi_5_5 25 pi_1_5 10 pi_5_3 26 pi_1_3 11 pi_5_1 27 pi_1_1 12 mi_5_1 28 mi_1_1 13 mi_5_3 29 mi_1_3 14 mi_5_5 30 mi_1_5 15 mi_5_7 31 mi_1_7 --- .../NR_TRANSPORT/nr_ulsch_llr_computation.c | 5063 +++-------------- 1 file changed, 693 insertions(+), 4370 deletions(-) diff --git a/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c b/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c index 50a2da40fb..ba8904be11 100644 --- a/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c +++ b/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c @@ -1395,11 +1395,11 @@ void nr_ulsch_qam64_qam64(c16_t *stream0_in, uint32_t length) { #ifdef USE_128BIT - simde__m128i *rho01_256i = (simde__m128i *)rho01; - simde__m128i *stream0_256i_in = (simde__m128i *)stream0_in; - simde__m128i *stream1_256i_in = (simde__m128i *)stream1_in; - simde__m128i *ch_mag_256i = (simde__m128i *)ch_mag; - simde__m128i *ch_mag_256i_i = (simde__m128i *)ch_mag_i; + simde__m128i *rho01_128i = (simde__m128i *)rho01; + simde__m128i *stream0_128i_in = (simde__m128i *)stream0_in; + simde__m128i *stream1_128i_in = (simde__m128i *)stream1_in; + simde__m128i *ch_mag_128i = (simde__m128i *)ch_mag; + simde__m128i *ch_mag_128i_i = (simde__m128i *)ch_mag_i; simde__m128i ONE_OVER_SQRT_42 = simde_mm_set1_epi16(10112); // round(1/sqrt(42)*2^16) simde__m128i THREE_OVER_SQRT_42 = simde_mm_set1_epi16(30337); // round(3/sqrt(42)*2^16) @@ -1447,26 +1447,27 @@ void nr_ulsch_qam64_qam64(c16_t *stream0_in, for (int i = 0; i < length >> 2; i += 2) { // Get rho - simde__m128i xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8; - simde_mm128_separate_real_imag_parts(&xmm2, &xmm3, rho01_256i[i], rho01_256i[i + 1]); + simde__m128i xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8; + simde_mm128_separate_real_imag_parts(&xmm2, &xmm3, rho01_128i[i], rho01_128i[i + 1]); simde__m128i rho_rpi = simde_mm_adds_epi16(xmm2, xmm3); // rho = Re(rho) + Im(rho) simde__m128i rho_rmi = simde_mm_subs_epi16(xmm2, xmm3); // rho* = Re(rho) - Im(rho) // Compute the different rhos - simde__m128i rho_rpi_1_1 = simde_mm_mulhi_epi16(rho_rpi, ONE_OVER_SQRT_42); - simde__m128i rho_rmi_1_1 = simde_mm_mulhi_epi16(rho_rmi, ONE_OVER_SQRT_42); - simde__m128i rho_rpi_3_3 = simde_mm_mulhi_epi16(rho_rpi, THREE_OVER_SQRT_42); - simde__m128i rho_rmi_3_3 = simde_mm_mulhi_epi16(rho_rmi, THREE_OVER_SQRT_42); - simde__m128i rho_rpi_5_5 = simde_mm_mulhi_epi16(rho_rpi, FIVE_OVER_SQRT_42); - simde__m128i rho_rmi_5_5 = simde_mm_mulhi_epi16(rho_rmi, FIVE_OVER_SQRT_42); - simde__m128i rho_rpi_7_7 = simde_mm_mulhi_epi16(rho_rpi, SEVEN_OVER_SQRT_42); - simde__m128i rho_rmi_7_7 = simde_mm_mulhi_epi16(rho_rmi, SEVEN_OVER_SQRT_42); + simde__m128i rho_rs[32] __attribute__((aligned(16))); + rho_rs[27] = simde_mm_mulhi_epi16(rho_rpi, ONE_OVER_SQRT_42); + rho_rs[28] = simde_mm_mulhi_epi16(rho_rmi, ONE_OVER_SQRT_42); + rho_rs[18] = simde_mm_mulhi_epi16(rho_rpi, THREE_OVER_SQRT_42); + rho_rs[21] = simde_mm_mulhi_epi16(rho_rmi, THREE_OVER_SQRT_42); + rho_rs[9] = simde_mm_mulhi_epi16(rho_rpi, FIVE_OVER_SQRT_42); + rho_rs[14] = simde_mm_mulhi_epi16(rho_rmi, FIVE_OVER_SQRT_42); + rho_rs[0] = simde_mm_mulhi_epi16(rho_rpi, SEVEN_OVER_SQRT_42); + rho_rs[7] = simde_mm_mulhi_epi16(rho_rmi, SEVEN_OVER_SQRT_42); - rho_rpi_5_5 = simde_mm_slli_epi16(rho_rpi_5_5, 1); - rho_rmi_5_5 = simde_mm_slli_epi16(rho_rmi_5_5, 1); - rho_rpi_7_7 = simde_mm_slli_epi16(rho_rpi_7_7, 2); - rho_rmi_7_7 = simde_mm_slli_epi16(rho_rmi_7_7, 2); + rho_rs[9] = simde_mm_slli_epi16(rho_rs[9], 1); + rho_rs[14] = simde_mm_slli_epi16(rho_rs[14], 1); + rho_rs[0] = simde_mm_slli_epi16(rho_rs[0], 2); + rho_rs[7] = simde_mm_slli_epi16(rho_rs[7], 2); xmm4 = simde_mm_mulhi_epi16(xmm2, ONE_OVER_SQRT_42); xmm5 = simde_mm_mulhi_epi16(xmm3, ONE_OVER_SQRT_42); @@ -1476,318 +1477,80 @@ void nr_ulsch_qam64_qam64(c16_t *stream0_in, xmm7 = simde_mm_slli_epi16(xmm7, 1); xmm8 = simde_mm_slli_epi16(xmm8, 2); - simde__m128i rho_rpi_1_3 = simde_mm_adds_epi16(xmm4, xmm6); - simde__m128i rho_rmi_1_3 = simde_mm_subs_epi16(xmm4, xmm6); - simde__m128i rho_rpi_1_5 = simde_mm_adds_epi16(xmm4, xmm7); - simde__m128i rho_rmi_1_5 = simde_mm_subs_epi16(xmm4, xmm7); - simde__m128i rho_rpi_1_7 = simde_mm_adds_epi16(xmm4, xmm8); - simde__m128i rho_rmi_1_7 = simde_mm_subs_epi16(xmm4, xmm8); + rho_rs[26] = simde_mm_adds_epi16(xmm4, xmm6); + rho_rs[29] = simde_mm_subs_epi16(xmm4, xmm6); + rho_rs[25] = simde_mm_adds_epi16(xmm4, xmm7); + rho_rs[30] = simde_mm_subs_epi16(xmm4, xmm7); + rho_rs[24] = simde_mm_adds_epi16(xmm4, xmm8); + rho_rs[31] = simde_mm_subs_epi16(xmm4, xmm8); xmm4 = simde_mm_mulhi_epi16(xmm2, THREE_OVER_SQRT_42); - simde__m128i rho_rpi_3_1 = simde_mm_adds_epi16(xmm4, xmm5); - simde__m128i rho_rmi_3_1 = simde_mm_subs_epi16(xmm4, xmm5); - simde__m128i rho_rpi_3_5 = simde_mm_adds_epi16(xmm4, xmm7); - simde__m128i rho_rmi_3_5 = simde_mm_subs_epi16(xmm4, xmm7); - simde__m128i rho_rpi_3_7 = simde_mm_adds_epi16(xmm4, xmm8); - simde__m128i rho_rmi_3_7 = simde_mm_subs_epi16(xmm4, xmm8); + rho_rs[19] = simde_mm_adds_epi16(xmm4, xmm5); + rho_rs[20] = simde_mm_subs_epi16(xmm4, xmm5); + rho_rs[17] = simde_mm_adds_epi16(xmm4, xmm7); + rho_rs[22] = simde_mm_subs_epi16(xmm4, xmm7); + rho_rs[16] = simde_mm_adds_epi16(xmm4, xmm8); + rho_rs[23] = simde_mm_subs_epi16(xmm4, xmm8); xmm4 = simde_mm_mulhi_epi16(xmm2, FIVE_OVER_SQRT_42); xmm4 = simde_mm_slli_epi16(xmm4, 1); - simde__m128i rho_rpi_5_1 = simde_mm_adds_epi16(xmm4, xmm5); - simde__m128i rho_rmi_5_1 = simde_mm_subs_epi16(xmm4, xmm5); - simde__m128i rho_rpi_5_3 = simde_mm_adds_epi16(xmm4, xmm6); - simde__m128i rho_rmi_5_3 = simde_mm_subs_epi16(xmm4, xmm6); - simde__m128i rho_rpi_5_7 = simde_mm_adds_epi16(xmm4, xmm8); - simde__m128i rho_rmi_5_7 = simde_mm_subs_epi16(xmm4, xmm8); + rho_rs[11] = simde_mm_adds_epi16(xmm4, xmm5); + rho_rs[12] = simde_mm_subs_epi16(xmm4, xmm5); + rho_rs[10] = simde_mm_adds_epi16(xmm4, xmm6); + rho_rs[13] = simde_mm_subs_epi16(xmm4, xmm6); + rho_rs[8] = simde_mm_adds_epi16(xmm4, xmm8); + rho_rs[15] = simde_mm_subs_epi16(xmm4, xmm8); xmm4 = simde_mm_mulhi_epi16(xmm2, SEVEN_OVER_SQRT_42); xmm4 = simde_mm_slli_epi16(xmm4, 2); - simde__m128i rho_rpi_7_1 = simde_mm_adds_epi16(xmm4, xmm5); - simde__m128i rho_rmi_7_1 = simde_mm_subs_epi16(xmm4, xmm5); - simde__m128i rho_rpi_7_3 = simde_mm_adds_epi16(xmm4, xmm6); - simde__m128i rho_rmi_7_3 = simde_mm_subs_epi16(xmm4, xmm6); - simde__m128i rho_rpi_7_5 = simde_mm_adds_epi16(xmm4, xmm7); - simde__m128i rho_rmi_7_5 = simde_mm_subs_epi16(xmm4, xmm7); + rho_rs[3] = simde_mm_adds_epi16(xmm4, xmm5); + rho_rs[4] = simde_mm_subs_epi16(xmm4, xmm5); + rho_rs[2] = simde_mm_adds_epi16(xmm4, xmm6); + rho_rs[5] = simde_mm_subs_epi16(xmm4, xmm6); + rho_rs[1] = simde_mm_adds_epi16(xmm4, xmm7); + rho_rs[6] = simde_mm_subs_epi16(xmm4, xmm7); // Rearrange interfering MF output - simde__m128i y1r, y1i, xmm0; - simde_mm128_separate_real_imag_parts(&y1r, &y1i, stream1_256i_in[i], stream1_256i_in[i + 1]); + simde__m128i y1r, y1i; + simde_mm128_separate_real_imag_parts(&y1r, &y1i, stream1_128i_in[i], stream1_128i_in[i + 1]); // Psi_r calculation from rho_rpi or rho_rmi xmm0 = simde_mm_set1_epi16(0); // ZERO for abs_pi16 - xmm2 = simde_mm_subs_epi16(rho_rpi_7_7, y1r); + xmm2 = simde_mm_subs_epi16(rho_rs[0], y1r); - simde__m128i psi_r_p7_p7 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_7_5, y1r); - simde__m128i psi_r_p7_p5 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_7_3, y1r); - simde__m128i psi_r_p7_p3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_7_1, y1r); - simde__m128i psi_r_p7_p1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_7_1, y1r); - simde__m128i psi_r_p7_m1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_7_3, y1r); - simde__m128i psi_r_p7_m3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_7_5, y1r); - simde__m128i psi_r_p7_m5 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_7_7, y1r); - simde__m128i psi_r_p7_m7 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_5_7, y1r); - simde__m128i psi_r_p5_p7 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_5_5, y1r); - simde__m128i psi_r_p5_p5 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_5_3, y1r); - simde__m128i psi_r_p5_p3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_5_1, y1r); - simde__m128i psi_r_p5_p1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_5_1, y1r); - simde__m128i psi_r_p5_m1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_5_3, y1r); - simde__m128i psi_r_p5_m3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_5_5, y1r); - simde__m128i psi_r_p5_m5 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_5_7, y1r); - simde__m128i psi_r_p5_m7 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_3_7, y1r); - simde__m128i psi_r_p3_p7 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_3_5, y1r); - simde__m128i psi_r_p3_p5 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_3_3, y1r); - simde__m128i psi_r_p3_p3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_3_1, y1r); - simde__m128i psi_r_p3_p1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_3_1, y1r); - simde__m128i psi_r_p3_m1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_3_3, y1r); - simde__m128i psi_r_p3_m3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_3_5, y1r); - simde__m128i psi_r_p3_m5 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_3_7, y1r); - simde__m128i psi_r_p3_m7 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_1_7, y1r); - simde__m128i psi_r_p1_p7 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_1_5, y1r); - simde__m128i psi_r_p1_p5 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_1_3, y1r); - simde__m128i psi_r_p1_p3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_1_1, y1r); - simde__m128i psi_r_p1_p1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_1_1, y1r); - simde__m128i psi_r_p1_m1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_1_3, y1r); - simde__m128i psi_r_p1_m3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_1_5, y1r); - simde__m128i psi_r_p1_m5 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_1_7, y1r); - simde__m128i psi_r_p1_m7 = simde_mm_abs_epi16(xmm2); + simde__m128i psi_r_s[64] __attribute__((aligned(16))); + for(int j=0; j<32; j++) // psi_r_s[0~31], rho_rs[0~31] + psi_r_s[j] = simde_mm_abs_epi16(simde_mm_subs_epi16(rho_rs[j], y1r)); + for(int j=32; j<64; j++) // psi_r_s[32~64], rho_rs[31~0] + psi_r_s[j] = simde_mm_abs_epi16(simde_mm_adds_epi16(rho_rs[63 - j], y1r)); - xmm2 = simde_mm_adds_epi16(rho_rmi_1_7, y1r); - simde__m128i psi_r_m1_p7 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rmi_1_5, y1r); - simde__m128i psi_r_m1_p5 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rmi_1_3, y1r); - simde__m128i psi_r_m1_p3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rmi_1_1, y1r); - simde__m128i psi_r_m1_p1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_1_1, y1r); - simde__m128i psi_r_m1_m1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_1_3, y1r); - simde__m128i psi_r_m1_m3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_1_5, y1r); - simde__m128i psi_r_m1_m5 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_1_7, y1r); - simde__m128i psi_r_m1_m7 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rmi_3_7, y1r); - simde__m128i psi_r_m3_p7 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rmi_3_5, y1r); - simde__m128i psi_r_m3_p5 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rmi_3_3, y1r); - simde__m128i psi_r_m3_p3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rmi_3_1, y1r); - simde__m128i psi_r_m3_p1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_3_1, y1r); - simde__m128i psi_r_m3_m1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_3_3, y1r); - simde__m128i psi_r_m3_m3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_3_5, y1r); - simde__m128i psi_r_m3_m5 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_3_7, y1r); - simde__m128i psi_r_m3_m7 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rmi_5_7, y1r); - simde__m128i psi_r_m5_p7 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rmi_5_5, y1r); - simde__m128i psi_r_m5_p5 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rmi_5_3, y1r); - simde__m128i psi_r_m5_p3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rmi_5_1, y1r); - simde__m128i psi_r_m5_p1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_5_1, y1r); - simde__m128i psi_r_m5_m1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_5_3, y1r); - simde__m128i psi_r_m5_m3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_5_5, y1r); - simde__m128i psi_r_m5_m5 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_5_7, y1r); - simde__m128i psi_r_m5_m7 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rmi_7_7, y1r); - simde__m128i psi_r_m7_p7 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rmi_7_5, y1r); - simde__m128i psi_r_m7_p5 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rmi_7_3, y1r); - simde__m128i psi_r_m7_p3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rmi_7_1, y1r); - simde__m128i psi_r_m7_p1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_7_1, y1r); - simde__m128i psi_r_m7_m1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_7_3, y1r); - simde__m128i psi_r_m7_m3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_7_5, y1r); - simde__m128i psi_r_m7_m5 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_7_7, y1r); - simde__m128i psi_r_m7_m7 = simde_mm_abs_epi16(xmm2); - - // simde__m128i Psi_i calculation from rho_rpi or rho_rmi - xmm2 = simde_mm_subs_epi16(rho_rmi_7_7, y1i); - simde__m128i psi_i_p7_p7 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_5_7, y1i); - simde__m128i psi_i_p7_p5 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_3_7, y1i); - simde__m128i psi_i_p7_p3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_1_7, y1i); - simde__m128i psi_i_p7_p1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_1_7, y1i); - simde__m128i psi_i_p7_m1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_3_7, y1i); - simde__m128i psi_i_p7_m3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_5_7, y1i); - simde__m128i psi_i_p7_m5 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_7_7, y1i); - simde__m128i psi_i_p7_m7 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_7_5, y1i); - simde__m128i psi_i_p5_p7 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_5_5, y1i); - simde__m128i psi_i_p5_p5 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_3_5, y1i); - simde__m128i psi_i_p5_p3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_1_5, y1i); - simde__m128i psi_i_p5_p1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_1_5, y1i); - simde__m128i psi_i_p5_m1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_3_5, y1i); - simde__m128i psi_i_p5_m3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_5_5, y1i); - simde__m128i psi_i_p5_m5 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_7_5, y1i); - simde__m128i psi_i_p5_m7 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_7_3, y1i); - simde__m128i psi_i_p3_p7 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_5_3, y1i); - simde__m128i psi_i_p3_p5 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_3_3, y1i); - simde__m128i psi_i_p3_p3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_1_3, y1i); - simde__m128i psi_i_p3_p1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_1_3, y1i); - simde__m128i psi_i_p3_m1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_3_3, y1i); - simde__m128i psi_i_p3_m3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_5_3, y1i); - simde__m128i psi_i_p3_m5 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_7_3, y1i); - simde__m128i psi_i_p3_m7 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_7_1, y1i); - simde__m128i psi_i_p1_p7 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_5_1, y1i); - simde__m128i psi_i_p1_p5 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_3_1, y1i); - simde__m128i psi_i_p1_p3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rmi_1_1, y1i); - simde__m128i psi_i_p1_p1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_1_1, y1i); - simde__m128i psi_i_p1_m1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_3_1, y1i); - simde__m128i psi_i_p1_m3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_5_1, y1i); - simde__m128i psi_i_p1_m5 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rpi_7_1, y1i); - simde__m128i psi_i_p1_m7 = simde_mm_abs_epi16(xmm2); - - xmm2 = simde_mm_subs_epi16(rho_rpi_7_1, y1i); - simde__m128i psi_i_m1_p7 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_5_1, y1i); - simde__m128i psi_i_m1_p5 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_3_1, y1i); - simde__m128i psi_i_m1_p3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_1_1, y1i); - simde__m128i psi_i_m1_p1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rmi_1_1, y1i); - simde__m128i psi_i_m1_m1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rmi_3_1, y1i); - simde__m128i psi_i_m1_m3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rmi_5_1, y1i); - simde__m128i psi_i_m1_m5 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rmi_7_1, y1i); - simde__m128i psi_i_m1_m7 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_7_3, y1i); - simde__m128i psi_i_m3_p7 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_5_3, y1i); - simde__m128i psi_i_m3_p5 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_3_3, y1i); - simde__m128i psi_i_m3_p3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_1_3, y1i); - simde__m128i psi_i_m3_p1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rmi_1_3, y1i); - simde__m128i psi_i_m3_m1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rmi_3_3, y1i); - simde__m128i psi_i_m3_m3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rmi_5_3, y1i); - simde__m128i psi_i_m3_m5 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rmi_7_3, y1i); - simde__m128i psi_i_m3_m7 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_7_5, y1i); - simde__m128i psi_i_m5_p7 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_5_5, y1i); - simde__m128i psi_i_m5_p5 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_3_5, y1i); - simde__m128i psi_i_m5_p3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_1_5, y1i); - simde__m128i psi_i_m5_p1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rmi_1_5, y1i); - simde__m128i psi_i_m5_m1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rmi_3_5, y1i); - simde__m128i psi_i_m5_m3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rmi_5_5, y1i); - simde__m128i psi_i_m5_m5 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rmi_7_5, y1i); - simde__m128i psi_i_m5_m7 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_7_7, y1i); - simde__m128i psi_i_m7_p7 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_5_7, y1i); - simde__m128i psi_i_m7_p5 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_3_7, y1i); - simde__m128i psi_i_m7_p3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_subs_epi16(rho_rpi_1_7, y1i); - simde__m128i psi_i_m7_p1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rmi_1_7, y1i); - simde__m128i psi_i_m7_m1 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rmi_3_7, y1i); - simde__m128i psi_i_m7_m3 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rmi_5_7, y1i); - simde__m128i psi_i_m7_m5 = simde_mm_abs_epi16(xmm2); - xmm2 = simde_mm_adds_epi16(rho_rmi_7_7, y1i); - simde__m128i psi_i_m7_m7 = simde_mm_abs_epi16(xmm2); + // simde__m128i psi_i calculation from rho_rpi or rho_rmi + simde__m128i psi_i_s[64] __attribute__((aligned(16))); + const uint8_t rho_rs_index[32] = {7,15,23,31,24,16,8,0,6,14,22,30,25,17,9,1,5,13,21,29,26,18,10,2,4,12,20,28,27,19,11,3}; + for(int k=0; k<32; k+=8){ // psi_i_s[0~31] + for(int j=k; j>3], y0i_seven_over_sqrt_21); + y0_s[j+1] = simde_mm_adds_epi16(y0r_over_s[j>>3], y0i_five_over_sqrt_21); + y0_s[j+2] = simde_mm_adds_epi16(y0r_over_s[j>>3], y0i_three_over_sqrt_21); + y0_s[j+3] = simde_mm_adds_epi16(y0r_over_s[j>>3], y0i_one_over_sqrt_21); + y0_s[j+4] = simde_mm_subs_epi16(y0r_over_s[j>>3], y0i_one_over_sqrt_21); + y0_s[j+5] = simde_mm_subs_epi16(y0r_over_s[j>>3], y0i_three_over_sqrt_21); + y0_s[j+6] = simde_mm_subs_epi16(y0r_over_s[j>>3], y0i_five_over_sqrt_21); + y0_s[j+7] = simde_mm_subs_epi16(y0r_over_s[j>>3], y0i_seven_over_sqrt_21); + } - simde__m128i y0_m_1_1 = simde_mm_subs_epi16(y0r_one_over_sqrt_21, y0i_one_over_sqrt_21); - simde__m128i y0_m_1_3 = simde_mm_subs_epi16(y0r_one_over_sqrt_21, y0i_three_over_sqrt_21); - simde__m128i y0_m_1_5 = simde_mm_subs_epi16(y0r_one_over_sqrt_21, y0i_five_over_sqrt_21); - simde__m128i y0_m_1_7 = simde_mm_subs_epi16(y0r_one_over_sqrt_21, y0i_seven_over_sqrt_21); - simde__m128i y0_m_3_1 = simde_mm_subs_epi16(y0r_three_over_sqrt_21, y0i_one_over_sqrt_21); - simde__m128i y0_m_3_3 = simde_mm_subs_epi16(y0r_three_over_sqrt_21, y0i_three_over_sqrt_21); - simde__m128i y0_m_3_5 = simde_mm_subs_epi16(y0r_three_over_sqrt_21, y0i_five_over_sqrt_21); - simde__m128i y0_m_3_7 = simde_mm_subs_epi16(y0r_three_over_sqrt_21, y0i_seven_over_sqrt_21); - simde__m128i y0_m_5_1 = simde_mm_subs_epi16(y0r_five_over_sqrt_21, y0i_one_over_sqrt_21); - simde__m128i y0_m_5_3 = simde_mm_subs_epi16(y0r_five_over_sqrt_21, y0i_three_over_sqrt_21); - simde__m128i y0_m_5_5 = simde_mm_subs_epi16(y0r_five_over_sqrt_21, y0i_five_over_sqrt_21); - simde__m128i y0_m_5_7 = simde_mm_subs_epi16(y0r_five_over_sqrt_21, y0i_seven_over_sqrt_21); - simde__m128i y0_m_7_1 = simde_mm_subs_epi16(y0r_seven_over_sqrt_21, y0i_one_over_sqrt_21); - simde__m128i y0_m_7_3 = simde_mm_subs_epi16(y0r_seven_over_sqrt_21, y0i_three_over_sqrt_21); - simde__m128i y0_m_7_5 = simde_mm_subs_epi16(y0r_seven_over_sqrt_21, y0i_five_over_sqrt_21); - simde__m128i y0_m_7_7 = simde_mm_subs_epi16(y0r_seven_over_sqrt_21, y0i_seven_over_sqrt_21); - - // Detection of interference term ch_mag_int_with_sigma2 = simde_mm_srai_epi16(ch_mag_int, 1); // *2 two_ch_mag_int_with_sigma2 = ch_mag_int; // *4 three_ch_mag_int_with_sigma2 = simde_mm_adds_epi16(ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2); // *6 - simde__m128i a_r_p7_p7 = interference_abs_64qam_epi16(psi_r_p7_p7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_p7_p5 = interference_abs_64qam_epi16(psi_r_p7_p5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_p7_p3 = interference_abs_64qam_epi16(psi_r_p7_p3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_p7_p1 = interference_abs_64qam_epi16(psi_r_p7_p1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_p7_m1 = interference_abs_64qam_epi16(psi_r_p7_m1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_p7_m3 = interference_abs_64qam_epi16(psi_r_p7_m3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_p7_m5 = interference_abs_64qam_epi16(psi_r_p7_m5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_p7_m7 = interference_abs_64qam_epi16(psi_r_p7_m7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_p5_p7 = interference_abs_64qam_epi16(psi_r_p5_p7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_p5_p5 = interference_abs_64qam_epi16(psi_r_p5_p5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_p5_p3 = interference_abs_64qam_epi16(psi_r_p5_p3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_p5_p1 = interference_abs_64qam_epi16(psi_r_p5_p1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_p5_m1 = interference_abs_64qam_epi16(psi_r_p5_m1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_p5_m3 = interference_abs_64qam_epi16(psi_r_p5_m3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_p5_m5 = interference_abs_64qam_epi16(psi_r_p5_m5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_p5_m7 = interference_abs_64qam_epi16(psi_r_p5_m7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_p3_p7 = interference_abs_64qam_epi16(psi_r_p3_p7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_p3_p5 = interference_abs_64qam_epi16(psi_r_p3_p5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_p3_p3 = interference_abs_64qam_epi16(psi_r_p3_p3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_p3_p1 = interference_abs_64qam_epi16(psi_r_p3_p1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_p3_m1 = interference_abs_64qam_epi16(psi_r_p3_m1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_p3_m3 = interference_abs_64qam_epi16(psi_r_p3_m3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_p3_m5 = interference_abs_64qam_epi16(psi_r_p3_m5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_p3_m7 = interference_abs_64qam_epi16(psi_r_p3_m7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_p1_p7 = interference_abs_64qam_epi16(psi_r_p1_p7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_p1_p5 = interference_abs_64qam_epi16(psi_r_p1_p5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_p1_p3 = interference_abs_64qam_epi16(psi_r_p1_p3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_p1_p1 = interference_abs_64qam_epi16(psi_r_p1_p1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_p1_m1 = interference_abs_64qam_epi16(psi_r_p1_m1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_p1_m3 = interference_abs_64qam_epi16(psi_r_p1_m3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_p1_m5 = interference_abs_64qam_epi16(psi_r_p1_m5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_p1_m7 = interference_abs_64qam_epi16(psi_r_p1_m7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_m1_p7 = interference_abs_64qam_epi16(psi_r_m1_p7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_m1_p5 = interference_abs_64qam_epi16(psi_r_m1_p5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_m1_p3 = interference_abs_64qam_epi16(psi_r_m1_p3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_m1_p1 = interference_abs_64qam_epi16(psi_r_m1_p1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_m1_m1 = interference_abs_64qam_epi16(psi_r_m1_m1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_m1_m3 = interference_abs_64qam_epi16(psi_r_m1_m3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_m1_m5 = interference_abs_64qam_epi16(psi_r_m1_m5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_m1_m7 = interference_abs_64qam_epi16(psi_r_m1_m7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_m3_p7 = interference_abs_64qam_epi16(psi_r_m3_p7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_m3_p5 = interference_abs_64qam_epi16(psi_r_m3_p5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_m3_p3 = interference_abs_64qam_epi16(psi_r_m3_p3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_m3_p1 = interference_abs_64qam_epi16(psi_r_m3_p1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_m3_m1 = interference_abs_64qam_epi16(psi_r_m3_m1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_m3_m3 = interference_abs_64qam_epi16(psi_r_m3_m3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_m3_m5 = interference_abs_64qam_epi16(psi_r_m3_m5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_m3_m7 = interference_abs_64qam_epi16(psi_r_m3_m7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_m5_p7 = interference_abs_64qam_epi16(psi_r_m5_p7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_m5_p5 = interference_abs_64qam_epi16(psi_r_m5_p5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_m5_p3 = interference_abs_64qam_epi16(psi_r_m5_p3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_m5_p1 = interference_abs_64qam_epi16(psi_r_m5_p1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_m5_m1 = interference_abs_64qam_epi16(psi_r_m5_m1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_m5_m3 = interference_abs_64qam_epi16(psi_r_m5_m3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_m5_m5 = interference_abs_64qam_epi16(psi_r_m5_m5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_m5_m7 = interference_abs_64qam_epi16(psi_r_m5_m7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_m7_p7 = interference_abs_64qam_epi16(psi_r_m7_p7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_m7_p5 = interference_abs_64qam_epi16(psi_r_m7_p5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_m7_p3 = interference_abs_64qam_epi16(psi_r_m7_p3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_m7_p1 = interference_abs_64qam_epi16(psi_r_m7_p1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_m7_m1 = interference_abs_64qam_epi16(psi_r_m7_m1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_m7_m3 = interference_abs_64qam_epi16(psi_r_m7_m3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_m7_m5 = interference_abs_64qam_epi16(psi_r_m7_m5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_r_m7_m7 = interference_abs_64qam_epi16(psi_r_m7_m7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); + simde__m128i a_r_s[64] __attribute__((aligned(16))); + simde__m128i a_i_s[64] __attribute__((aligned(16))); + simde__m128i psi_a_s[64] __attribute__((aligned(16))); + simde__m128i a_sq_s[64] __attribute__((aligned(16))); + for(int j=0; j<64; j++){ + // Detection of interference term + a_r_s[j] = interference_abs_64qam_epi16(psi_r_s[j], ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); + a_i_s[j] = interference_abs_64qam_epi16(psi_i_s[j], ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); + + // Calculation of a group of two terms in the bit metric involving product of psi and interference + psi_a_s[j] = prodsum_psi_a_epi16(psi_r_s[j], a_r_s[j], psi_i_s[j], a_i_s[j]); - simde__m128i a_i_p7_p7 = interference_abs_64qam_epi16(psi_i_p7_p7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_p7_p5 = interference_abs_64qam_epi16(psi_i_p7_p5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_p7_p3 = interference_abs_64qam_epi16(psi_i_p7_p3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_p7_p1 = interference_abs_64qam_epi16(psi_i_p7_p1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_p7_m1 = interference_abs_64qam_epi16(psi_i_p7_m1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_p7_m3 = interference_abs_64qam_epi16(psi_i_p7_m3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_p7_m5 = interference_abs_64qam_epi16(psi_i_p7_m5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_p7_m7 = interference_abs_64qam_epi16(psi_i_p7_m7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_p5_p7 = interference_abs_64qam_epi16(psi_i_p5_p7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_p5_p5 = interference_abs_64qam_epi16(psi_i_p5_p5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_p5_p3 = interference_abs_64qam_epi16(psi_i_p5_p3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_p5_p1 = interference_abs_64qam_epi16(psi_i_p5_p1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_p5_m1 = interference_abs_64qam_epi16(psi_i_p5_m1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_p5_m3 = interference_abs_64qam_epi16(psi_i_p5_m3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_p5_m5 = interference_abs_64qam_epi16(psi_i_p5_m5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_p5_m7 = interference_abs_64qam_epi16(psi_i_p5_m7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_p3_p7 = interference_abs_64qam_epi16(psi_i_p3_p7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_p3_p5 = interference_abs_64qam_epi16(psi_i_p3_p5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_p3_p3 = interference_abs_64qam_epi16(psi_i_p3_p3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_p3_p1 = interference_abs_64qam_epi16(psi_i_p3_p1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_p3_m1 = interference_abs_64qam_epi16(psi_i_p3_m1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_p3_m3 = interference_abs_64qam_epi16(psi_i_p3_m3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_p3_m5 = interference_abs_64qam_epi16(psi_i_p3_m5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_p3_m7 = interference_abs_64qam_epi16(psi_i_p3_m7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_p1_p7 = interference_abs_64qam_epi16(psi_i_p1_p7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_p1_p5 = interference_abs_64qam_epi16(psi_i_p1_p5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_p1_p3 = interference_abs_64qam_epi16(psi_i_p1_p3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_p1_p1 = interference_abs_64qam_epi16(psi_i_p1_p1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_p1_m1 = interference_abs_64qam_epi16(psi_i_p1_m1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_p1_m3 = interference_abs_64qam_epi16(psi_i_p1_m3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_p1_m5 = interference_abs_64qam_epi16(psi_i_p1_m5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_p1_m7 = interference_abs_64qam_epi16(psi_i_p1_m7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_m1_p7 = interference_abs_64qam_epi16(psi_i_m1_p7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_m1_p5 = interference_abs_64qam_epi16(psi_i_m1_p5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_m1_p3 = interference_abs_64qam_epi16(psi_i_m1_p3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_m1_p1 = interference_abs_64qam_epi16(psi_i_m1_p1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_m1_m1 = interference_abs_64qam_epi16(psi_i_m1_m1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_m1_m3 = interference_abs_64qam_epi16(psi_i_m1_m3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_m1_m5 = interference_abs_64qam_epi16(psi_i_m1_m5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_m1_m7 = interference_abs_64qam_epi16(psi_i_m1_m7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_m3_p7 = interference_abs_64qam_epi16(psi_i_m3_p7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_m3_p5 = interference_abs_64qam_epi16(psi_i_m3_p5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_m3_p3 = interference_abs_64qam_epi16(psi_i_m3_p3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_m3_p1 = interference_abs_64qam_epi16(psi_i_m3_p1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_m3_m1 = interference_abs_64qam_epi16(psi_i_m3_m1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_m3_m3 = interference_abs_64qam_epi16(psi_i_m3_m3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_m3_m5 = interference_abs_64qam_epi16(psi_i_m3_m5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_m3_m7 = interference_abs_64qam_epi16(psi_i_m3_m7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_m5_p7 = interference_abs_64qam_epi16(psi_i_m5_p7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_m5_p5 = interference_abs_64qam_epi16(psi_i_m5_p5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_m5_p3 = interference_abs_64qam_epi16(psi_i_m5_p3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_m5_p1 = interference_abs_64qam_epi16(psi_i_m5_p1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_m5_m1 = interference_abs_64qam_epi16(psi_i_m5_m1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_m5_m3 = interference_abs_64qam_epi16(psi_i_m5_m3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_m5_m5 = interference_abs_64qam_epi16(psi_i_m5_m5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_m5_m7 = interference_abs_64qam_epi16(psi_i_m5_m7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_m7_p7 = interference_abs_64qam_epi16(psi_i_m7_p7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_m7_p5 = interference_abs_64qam_epi16(psi_i_m7_p5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_m7_p3 = interference_abs_64qam_epi16(psi_i_m7_p3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_m7_p1 = interference_abs_64qam_epi16(psi_i_m7_p1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_m7_m1 = interference_abs_64qam_epi16(psi_i_m7_m1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_m7_m3 = interference_abs_64qam_epi16(psi_i_m7_m3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_m7_m5 = interference_abs_64qam_epi16(psi_i_m7_m5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m128i a_i_m7_m7 = interference_abs_64qam_epi16(psi_i_m7_m7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); + // Multiply by sqrt(2) + psi_a_s[j] = simde_mm_slli_epi16(simde_mm_mulhi_epi16(psi_a_s[j], ONE_OVER_SQRT_2), 2); - // Calculation of a group of two terms in the bit metric involving product of psi and interference - simde__m128i psi_a_p7_p7 = prodsum_psi_a_epi16(psi_r_p7_p7, a_r_p7_p7, psi_i_p7_p7, a_i_p7_p7); - simde__m128i psi_a_p7_p5 = prodsum_psi_a_epi16(psi_r_p7_p5, a_r_p7_p5, psi_i_p7_p5, a_i_p7_p5); - simde__m128i psi_a_p7_p3 = prodsum_psi_a_epi16(psi_r_p7_p3, a_r_p7_p3, psi_i_p7_p3, a_i_p7_p3); - simde__m128i psi_a_p7_p1 = prodsum_psi_a_epi16(psi_r_p7_p1, a_r_p7_p1, psi_i_p7_p1, a_i_p7_p1); - simde__m128i psi_a_p7_m1 = prodsum_psi_a_epi16(psi_r_p7_m1, a_r_p7_m1, psi_i_p7_m1, a_i_p7_m1); - simde__m128i psi_a_p7_m3 = prodsum_psi_a_epi16(psi_r_p7_m3, a_r_p7_m3, psi_i_p7_m3, a_i_p7_m3); - simde__m128i psi_a_p7_m5 = prodsum_psi_a_epi16(psi_r_p7_m5, a_r_p7_m5, psi_i_p7_m5, a_i_p7_m5); - simde__m128i psi_a_p7_m7 = prodsum_psi_a_epi16(psi_r_p7_m7, a_r_p7_m7, psi_i_p7_m7, a_i_p7_m7); - simde__m128i psi_a_p5_p7 = prodsum_psi_a_epi16(psi_r_p5_p7, a_r_p5_p7, psi_i_p5_p7, a_i_p5_p7); - simde__m128i psi_a_p5_p5 = prodsum_psi_a_epi16(psi_r_p5_p5, a_r_p5_p5, psi_i_p5_p5, a_i_p5_p5); - simde__m128i psi_a_p5_p3 = prodsum_psi_a_epi16(psi_r_p5_p3, a_r_p5_p3, psi_i_p5_p3, a_i_p5_p3); - simde__m128i psi_a_p5_p1 = prodsum_psi_a_epi16(psi_r_p5_p1, a_r_p5_p1, psi_i_p5_p1, a_i_p5_p1); - simde__m128i psi_a_p5_m1 = prodsum_psi_a_epi16(psi_r_p5_m1, a_r_p5_m1, psi_i_p5_m1, a_i_p5_m1); - simde__m128i psi_a_p5_m3 = prodsum_psi_a_epi16(psi_r_p5_m3, a_r_p5_m3, psi_i_p5_m3, a_i_p5_m3); - simde__m128i psi_a_p5_m5 = prodsum_psi_a_epi16(psi_r_p5_m5, a_r_p5_m5, psi_i_p5_m5, a_i_p5_m5); - simde__m128i psi_a_p5_m7 = prodsum_psi_a_epi16(psi_r_p5_m7, a_r_p5_m7, psi_i_p5_m7, a_i_p5_m7); - simde__m128i psi_a_p3_p7 = prodsum_psi_a_epi16(psi_r_p3_p7, a_r_p3_p7, psi_i_p3_p7, a_i_p3_p7); - simde__m128i psi_a_p3_p5 = prodsum_psi_a_epi16(psi_r_p3_p5, a_r_p3_p5, psi_i_p3_p5, a_i_p3_p5); - simde__m128i psi_a_p3_p3 = prodsum_psi_a_epi16(psi_r_p3_p3, a_r_p3_p3, psi_i_p3_p3, a_i_p3_p3); - simde__m128i psi_a_p3_p1 = prodsum_psi_a_epi16(psi_r_p3_p1, a_r_p3_p1, psi_i_p3_p1, a_i_p3_p1); - simde__m128i psi_a_p3_m1 = prodsum_psi_a_epi16(psi_r_p3_m1, a_r_p3_m1, psi_i_p3_m1, a_i_p3_m1); - simde__m128i psi_a_p3_m3 = prodsum_psi_a_epi16(psi_r_p3_m3, a_r_p3_m3, psi_i_p3_m3, a_i_p3_m3); - simde__m128i psi_a_p3_m5 = prodsum_psi_a_epi16(psi_r_p3_m5, a_r_p3_m5, psi_i_p3_m5, a_i_p3_m5); - simde__m128i psi_a_p3_m7 = prodsum_psi_a_epi16(psi_r_p3_m7, a_r_p3_m7, psi_i_p3_m7, a_i_p3_m7); - simde__m128i psi_a_p1_p7 = prodsum_psi_a_epi16(psi_r_p1_p7, a_r_p1_p7, psi_i_p1_p7, a_i_p1_p7); - simde__m128i psi_a_p1_p5 = prodsum_psi_a_epi16(psi_r_p1_p5, a_r_p1_p5, psi_i_p1_p5, a_i_p1_p5); - simde__m128i psi_a_p1_p3 = prodsum_psi_a_epi16(psi_r_p1_p3, a_r_p1_p3, psi_i_p1_p3, a_i_p1_p3); - simde__m128i psi_a_p1_p1 = prodsum_psi_a_epi16(psi_r_p1_p1, a_r_p1_p1, psi_i_p1_p1, a_i_p1_p1); - simde__m128i psi_a_p1_m1 = prodsum_psi_a_epi16(psi_r_p1_m1, a_r_p1_m1, psi_i_p1_m1, a_i_p1_m1); - simde__m128i psi_a_p1_m3 = prodsum_psi_a_epi16(psi_r_p1_m3, a_r_p1_m3, psi_i_p1_m3, a_i_p1_m3); - simde__m128i psi_a_p1_m5 = prodsum_psi_a_epi16(psi_r_p1_m5, a_r_p1_m5, psi_i_p1_m5, a_i_p1_m5); - simde__m128i psi_a_p1_m7 = prodsum_psi_a_epi16(psi_r_p1_m7, a_r_p1_m7, psi_i_p1_m7, a_i_p1_m7); - simde__m128i psi_a_m1_p7 = prodsum_psi_a_epi16(psi_r_m1_p7, a_r_m1_p7, psi_i_m1_p7, a_i_m1_p7); - simde__m128i psi_a_m1_p5 = prodsum_psi_a_epi16(psi_r_m1_p5, a_r_m1_p5, psi_i_m1_p5, a_i_m1_p5); - simde__m128i psi_a_m1_p3 = prodsum_psi_a_epi16(psi_r_m1_p3, a_r_m1_p3, psi_i_m1_p3, a_i_m1_p3); - simde__m128i psi_a_m1_p1 = prodsum_psi_a_epi16(psi_r_m1_p1, a_r_m1_p1, psi_i_m1_p1, a_i_m1_p1); - simde__m128i psi_a_m1_m1 = prodsum_psi_a_epi16(psi_r_m1_m1, a_r_m1_m1, psi_i_m1_m1, a_i_m1_m1); - simde__m128i psi_a_m1_m3 = prodsum_psi_a_epi16(psi_r_m1_m3, a_r_m1_m3, psi_i_m1_m3, a_i_m1_m3); - simde__m128i psi_a_m1_m5 = prodsum_psi_a_epi16(psi_r_m1_m5, a_r_m1_m5, psi_i_m1_m5, a_i_m1_m5); - simde__m128i psi_a_m1_m7 = prodsum_psi_a_epi16(psi_r_m1_m7, a_r_m1_m7, psi_i_m1_m7, a_i_m1_m7); - simde__m128i psi_a_m3_p7 = prodsum_psi_a_epi16(psi_r_m3_p7, a_r_m3_p7, psi_i_m3_p7, a_i_m3_p7); - simde__m128i psi_a_m3_p5 = prodsum_psi_a_epi16(psi_r_m3_p5, a_r_m3_p5, psi_i_m3_p5, a_i_m3_p5); - simde__m128i psi_a_m3_p3 = prodsum_psi_a_epi16(psi_r_m3_p3, a_r_m3_p3, psi_i_m3_p3, a_i_m3_p3); - simde__m128i psi_a_m3_p1 = prodsum_psi_a_epi16(psi_r_m3_p1, a_r_m3_p1, psi_i_m3_p1, a_i_m3_p1); - simde__m128i psi_a_m3_m1 = prodsum_psi_a_epi16(psi_r_m3_m1, a_r_m3_m1, psi_i_m3_m1, a_i_m3_m1); - simde__m128i psi_a_m3_m3 = prodsum_psi_a_epi16(psi_r_m3_m3, a_r_m3_m3, psi_i_m3_m3, a_i_m3_m3); - simde__m128i psi_a_m3_m5 = prodsum_psi_a_epi16(psi_r_m3_m5, a_r_m3_m5, psi_i_m3_m5, a_i_m3_m5); - simde__m128i psi_a_m3_m7 = prodsum_psi_a_epi16(psi_r_m3_m7, a_r_m3_m7, psi_i_m3_m7, a_i_m3_m7); - simde__m128i psi_a_m5_p7 = prodsum_psi_a_epi16(psi_r_m5_p7, a_r_m5_p7, psi_i_m5_p7, a_i_m5_p7); - simde__m128i psi_a_m5_p5 = prodsum_psi_a_epi16(psi_r_m5_p5, a_r_m5_p5, psi_i_m5_p5, a_i_m5_p5); - simde__m128i psi_a_m5_p3 = prodsum_psi_a_epi16(psi_r_m5_p3, a_r_m5_p3, psi_i_m5_p3, a_i_m5_p3); - simde__m128i psi_a_m5_p1 = prodsum_psi_a_epi16(psi_r_m5_p1, a_r_m5_p1, psi_i_m5_p1, a_i_m5_p1); - simde__m128i psi_a_m5_m1 = prodsum_psi_a_epi16(psi_r_m5_m1, a_r_m5_m1, psi_i_m5_m1, a_i_m5_m1); - simde__m128i psi_a_m5_m3 = prodsum_psi_a_epi16(psi_r_m5_m3, a_r_m5_m3, psi_i_m5_m3, a_i_m5_m3); - simde__m128i psi_a_m5_m5 = prodsum_psi_a_epi16(psi_r_m5_m5, a_r_m5_m5, psi_i_m5_m5, a_i_m5_m5); - simde__m128i psi_a_m5_m7 = prodsum_psi_a_epi16(psi_r_m5_m7, a_r_m5_m7, psi_i_m5_m7, a_i_m5_m7); - simde__m128i psi_a_m7_p7 = prodsum_psi_a_epi16(psi_r_m7_p7, a_r_m7_p7, psi_i_m7_p7, a_i_m7_p7); - simde__m128i psi_a_m7_p5 = prodsum_psi_a_epi16(psi_r_m7_p5, a_r_m7_p5, psi_i_m7_p5, a_i_m7_p5); - simde__m128i psi_a_m7_p3 = prodsum_psi_a_epi16(psi_r_m7_p3, a_r_m7_p3, psi_i_m7_p3, a_i_m7_p3); - simde__m128i psi_a_m7_p1 = prodsum_psi_a_epi16(psi_r_m7_p1, a_r_m7_p1, psi_i_m7_p1, a_i_m7_p1); - simde__m128i psi_a_m7_m1 = prodsum_psi_a_epi16(psi_r_m7_m1, a_r_m7_m1, psi_i_m7_m1, a_i_m7_m1); - simde__m128i psi_a_m7_m3 = prodsum_psi_a_epi16(psi_r_m7_m3, a_r_m7_m3, psi_i_m7_m3, a_i_m7_m3); - simde__m128i psi_a_m7_m5 = prodsum_psi_a_epi16(psi_r_m7_m5, a_r_m7_m5, psi_i_m7_m5, a_i_m7_m5); - simde__m128i psi_a_m7_m7 = prodsum_psi_a_epi16(psi_r_m7_m7, a_r_m7_m7, psi_i_m7_m7, a_i_m7_m7); - - // Multiply by sqrt(2) - psi_a_p7_p7 = simde_mm_mulhi_epi16(psi_a_p7_p7, ONE_OVER_SQRT_2); - psi_a_p7_p7 = simde_mm_slli_epi16(psi_a_p7_p7, 2); - psi_a_p7_p5 = simde_mm_mulhi_epi16(psi_a_p7_p5, ONE_OVER_SQRT_2); - psi_a_p7_p5 = simde_mm_slli_epi16(psi_a_p7_p5, 2); - psi_a_p7_p3 = simde_mm_mulhi_epi16(psi_a_p7_p3, ONE_OVER_SQRT_2); - psi_a_p7_p3 = simde_mm_slli_epi16(psi_a_p7_p3, 2); - psi_a_p7_p1 = simde_mm_mulhi_epi16(psi_a_p7_p1, ONE_OVER_SQRT_2); - psi_a_p7_p1 = simde_mm_slli_epi16(psi_a_p7_p1, 2); - psi_a_p7_m1 = simde_mm_mulhi_epi16(psi_a_p7_m1, ONE_OVER_SQRT_2); - psi_a_p7_m1 = simde_mm_slli_epi16(psi_a_p7_m1, 2); - psi_a_p7_m3 = simde_mm_mulhi_epi16(psi_a_p7_m3, ONE_OVER_SQRT_2); - psi_a_p7_m3 = simde_mm_slli_epi16(psi_a_p7_m3, 2); - psi_a_p7_m5 = simde_mm_mulhi_epi16(psi_a_p7_m5, ONE_OVER_SQRT_2); - psi_a_p7_m5 = simde_mm_slli_epi16(psi_a_p7_m5, 2); - psi_a_p7_m7 = simde_mm_mulhi_epi16(psi_a_p7_m7, ONE_OVER_SQRT_2); - psi_a_p7_m7 = simde_mm_slli_epi16(psi_a_p7_m7, 2); - psi_a_p5_p7 = simde_mm_mulhi_epi16(psi_a_p5_p7, ONE_OVER_SQRT_2); - psi_a_p5_p7 = simde_mm_slli_epi16(psi_a_p5_p7, 2); - psi_a_p5_p5 = simde_mm_mulhi_epi16(psi_a_p5_p5, ONE_OVER_SQRT_2); - psi_a_p5_p5 = simde_mm_slli_epi16(psi_a_p5_p5, 2); - psi_a_p5_p3 = simde_mm_mulhi_epi16(psi_a_p5_p3, ONE_OVER_SQRT_2); - psi_a_p5_p3 = simde_mm_slli_epi16(psi_a_p5_p3, 2); - psi_a_p5_p1 = simde_mm_mulhi_epi16(psi_a_p5_p1, ONE_OVER_SQRT_2); - psi_a_p5_p1 = simde_mm_slli_epi16(psi_a_p5_p1, 2); - psi_a_p5_m1 = simde_mm_mulhi_epi16(psi_a_p5_m1, ONE_OVER_SQRT_2); - psi_a_p5_m1 = simde_mm_slli_epi16(psi_a_p5_m1, 2); - psi_a_p5_m3 = simde_mm_mulhi_epi16(psi_a_p5_m3, ONE_OVER_SQRT_2); - psi_a_p5_m3 = simde_mm_slli_epi16(psi_a_p5_m3, 2); - psi_a_p5_m5 = simde_mm_mulhi_epi16(psi_a_p5_m5, ONE_OVER_SQRT_2); - psi_a_p5_m5 = simde_mm_slli_epi16(psi_a_p5_m5, 2); - psi_a_p5_m7 = simde_mm_mulhi_epi16(psi_a_p5_m7, ONE_OVER_SQRT_2); - psi_a_p5_m7 = simde_mm_slli_epi16(psi_a_p5_m7, 2); - psi_a_p3_p7 = simde_mm_mulhi_epi16(psi_a_p3_p7, ONE_OVER_SQRT_2); - psi_a_p3_p7 = simde_mm_slli_epi16(psi_a_p3_p7, 2); - psi_a_p3_p5 = simde_mm_mulhi_epi16(psi_a_p3_p5, ONE_OVER_SQRT_2); - psi_a_p3_p5 = simde_mm_slli_epi16(psi_a_p3_p5, 2); - psi_a_p3_p3 = simde_mm_mulhi_epi16(psi_a_p3_p3, ONE_OVER_SQRT_2); - psi_a_p3_p3 = simde_mm_slli_epi16(psi_a_p3_p3, 2); - psi_a_p3_p1 = simde_mm_mulhi_epi16(psi_a_p3_p1, ONE_OVER_SQRT_2); - psi_a_p3_p1 = simde_mm_slli_epi16(psi_a_p3_p1, 2); - psi_a_p3_m1 = simde_mm_mulhi_epi16(psi_a_p3_m1, ONE_OVER_SQRT_2); - psi_a_p3_m1 = simde_mm_slli_epi16(psi_a_p3_m1, 2); - psi_a_p3_m3 = simde_mm_mulhi_epi16(psi_a_p3_m3, ONE_OVER_SQRT_2); - psi_a_p3_m3 = simde_mm_slli_epi16(psi_a_p3_m3, 2); - psi_a_p3_m5 = simde_mm_mulhi_epi16(psi_a_p3_m5, ONE_OVER_SQRT_2); - psi_a_p3_m5 = simde_mm_slli_epi16(psi_a_p3_m5, 2); - psi_a_p3_m7 = simde_mm_mulhi_epi16(psi_a_p3_m7, ONE_OVER_SQRT_2); - psi_a_p3_m7 = simde_mm_slli_epi16(psi_a_p3_m7, 2); - psi_a_p1_p7 = simde_mm_mulhi_epi16(psi_a_p1_p7, ONE_OVER_SQRT_2); - psi_a_p1_p7 = simde_mm_slli_epi16(psi_a_p1_p7, 2); - psi_a_p1_p5 = simde_mm_mulhi_epi16(psi_a_p1_p5, ONE_OVER_SQRT_2); - psi_a_p1_p5 = simde_mm_slli_epi16(psi_a_p1_p5, 2); - psi_a_p1_p3 = simde_mm_mulhi_epi16(psi_a_p1_p3, ONE_OVER_SQRT_2); - psi_a_p1_p3 = simde_mm_slli_epi16(psi_a_p1_p3, 2); - psi_a_p1_p1 = simde_mm_mulhi_epi16(psi_a_p1_p1, ONE_OVER_SQRT_2); - psi_a_p1_p1 = simde_mm_slli_epi16(psi_a_p1_p1, 2); - psi_a_p1_m1 = simde_mm_mulhi_epi16(psi_a_p1_m1, ONE_OVER_SQRT_2); - psi_a_p1_m1 = simde_mm_slli_epi16(psi_a_p1_m1, 2); - psi_a_p1_m3 = simde_mm_mulhi_epi16(psi_a_p1_m3, ONE_OVER_SQRT_2); - psi_a_p1_m3 = simde_mm_slli_epi16(psi_a_p1_m3, 2); - psi_a_p1_m5 = simde_mm_mulhi_epi16(psi_a_p1_m5, ONE_OVER_SQRT_2); - psi_a_p1_m5 = simde_mm_slli_epi16(psi_a_p1_m5, 2); - psi_a_p1_m7 = simde_mm_mulhi_epi16(psi_a_p1_m7, ONE_OVER_SQRT_2); - psi_a_p1_m7 = simde_mm_slli_epi16(psi_a_p1_m7, 2); - psi_a_m1_p7 = simde_mm_mulhi_epi16(psi_a_m1_p7, ONE_OVER_SQRT_2); - psi_a_m1_p7 = simde_mm_slli_epi16(psi_a_m1_p7, 2); - psi_a_m1_p5 = simde_mm_mulhi_epi16(psi_a_m1_p5, ONE_OVER_SQRT_2); - psi_a_m1_p5 = simde_mm_slli_epi16(psi_a_m1_p5, 2); - psi_a_m1_p3 = simde_mm_mulhi_epi16(psi_a_m1_p3, ONE_OVER_SQRT_2); - psi_a_m1_p3 = simde_mm_slli_epi16(psi_a_m1_p3, 2); - psi_a_m1_p1 = simde_mm_mulhi_epi16(psi_a_m1_p1, ONE_OVER_SQRT_2); - psi_a_m1_p1 = simde_mm_slli_epi16(psi_a_m1_p1, 2); - psi_a_m1_m1 = simde_mm_mulhi_epi16(psi_a_m1_m1, ONE_OVER_SQRT_2); - psi_a_m1_m1 = simde_mm_slli_epi16(psi_a_m1_m1, 2); - psi_a_m1_m3 = simde_mm_mulhi_epi16(psi_a_m1_m3, ONE_OVER_SQRT_2); - psi_a_m1_m3 = simde_mm_slli_epi16(psi_a_m1_m3, 2); - psi_a_m1_m5 = simde_mm_mulhi_epi16(psi_a_m1_m5, ONE_OVER_SQRT_2); - psi_a_m1_m5 = simde_mm_slli_epi16(psi_a_m1_m5, 2); - psi_a_m1_m7 = simde_mm_mulhi_epi16(psi_a_m1_m7, ONE_OVER_SQRT_2); - psi_a_m1_m7 = simde_mm_slli_epi16(psi_a_m1_m7, 2); - psi_a_m3_p7 = simde_mm_mulhi_epi16(psi_a_m3_p7, ONE_OVER_SQRT_2); - psi_a_m3_p7 = simde_mm_slli_epi16(psi_a_m3_p7, 2); - psi_a_m3_p5 = simde_mm_mulhi_epi16(psi_a_m3_p5, ONE_OVER_SQRT_2); - psi_a_m3_p5 = simde_mm_slli_epi16(psi_a_m3_p5, 2); - psi_a_m3_p3 = simde_mm_mulhi_epi16(psi_a_m3_p3, ONE_OVER_SQRT_2); - psi_a_m3_p3 = simde_mm_slli_epi16(psi_a_m3_p3, 2); - psi_a_m3_p1 = simde_mm_mulhi_epi16(psi_a_m3_p1, ONE_OVER_SQRT_2); - psi_a_m3_p1 = simde_mm_slli_epi16(psi_a_m3_p1, 2); - psi_a_m3_m1 = simde_mm_mulhi_epi16(psi_a_m3_m1, ONE_OVER_SQRT_2); - psi_a_m3_m1 = simde_mm_slli_epi16(psi_a_m3_m1, 2); - psi_a_m3_m3 = simde_mm_mulhi_epi16(psi_a_m3_m3, ONE_OVER_SQRT_2); - psi_a_m3_m3 = simde_mm_slli_epi16(psi_a_m3_m3, 2); - psi_a_m3_m5 = simde_mm_mulhi_epi16(psi_a_m3_m5, ONE_OVER_SQRT_2); - psi_a_m3_m5 = simde_mm_slli_epi16(psi_a_m3_m5, 2); - psi_a_m3_m7 = simde_mm_mulhi_epi16(psi_a_m3_m7, ONE_OVER_SQRT_2); - psi_a_m3_m7 = simde_mm_slli_epi16(psi_a_m3_m7, 2); - psi_a_m5_p7 = simde_mm_mulhi_epi16(psi_a_m5_p7, ONE_OVER_SQRT_2); - psi_a_m5_p7 = simde_mm_slli_epi16(psi_a_m5_p7, 2); - psi_a_m5_p5 = simde_mm_mulhi_epi16(psi_a_m5_p5, ONE_OVER_SQRT_2); - psi_a_m5_p5 = simde_mm_slli_epi16(psi_a_m5_p5, 2); - psi_a_m5_p3 = simde_mm_mulhi_epi16(psi_a_m5_p3, ONE_OVER_SQRT_2); - psi_a_m5_p3 = simde_mm_slli_epi16(psi_a_m5_p3, 2); - psi_a_m5_p1 = simde_mm_mulhi_epi16(psi_a_m5_p1, ONE_OVER_SQRT_2); - psi_a_m5_p1 = simde_mm_slli_epi16(psi_a_m5_p1, 2); - psi_a_m5_m1 = simde_mm_mulhi_epi16(psi_a_m5_m1, ONE_OVER_SQRT_2); - psi_a_m5_m1 = simde_mm_slli_epi16(psi_a_m5_m1, 2); - psi_a_m5_m3 = simde_mm_mulhi_epi16(psi_a_m5_m3, ONE_OVER_SQRT_2); - psi_a_m5_m3 = simde_mm_slli_epi16(psi_a_m5_m3, 2); - psi_a_m5_m5 = simde_mm_mulhi_epi16(psi_a_m5_m5, ONE_OVER_SQRT_2); - psi_a_m5_m5 = simde_mm_slli_epi16(psi_a_m5_m5, 2); - psi_a_m5_m7 = simde_mm_mulhi_epi16(psi_a_m5_m7, ONE_OVER_SQRT_2); - psi_a_m5_m7 = simde_mm_slli_epi16(psi_a_m5_m7, 2); - psi_a_m7_p7 = simde_mm_mulhi_epi16(psi_a_m7_p7, ONE_OVER_SQRT_2); - psi_a_m7_p7 = simde_mm_slli_epi16(psi_a_m7_p7, 2); - psi_a_m7_p5 = simde_mm_mulhi_epi16(psi_a_m7_p5, ONE_OVER_SQRT_2); - psi_a_m7_p5 = simde_mm_slli_epi16(psi_a_m7_p5, 2); - psi_a_m7_p3 = simde_mm_mulhi_epi16(psi_a_m7_p3, ONE_OVER_SQRT_2); - psi_a_m7_p3 = simde_mm_slli_epi16(psi_a_m7_p3, 2); - psi_a_m7_p1 = simde_mm_mulhi_epi16(psi_a_m7_p1, ONE_OVER_SQRT_2); - psi_a_m7_p1 = simde_mm_slli_epi16(psi_a_m7_p1, 2); - psi_a_m7_m1 = simde_mm_mulhi_epi16(psi_a_m7_m1, ONE_OVER_SQRT_2); - psi_a_m7_m1 = simde_mm_slli_epi16(psi_a_m7_m1, 2); - psi_a_m7_m3 = simde_mm_mulhi_epi16(psi_a_m7_m3, ONE_OVER_SQRT_2); - psi_a_m7_m3 = simde_mm_slli_epi16(psi_a_m7_m3, 2); - psi_a_m7_m5 = simde_mm_mulhi_epi16(psi_a_m7_m5, ONE_OVER_SQRT_2); - psi_a_m7_m5 = simde_mm_slli_epi16(psi_a_m7_m5, 2); - psi_a_m7_m7 = simde_mm_mulhi_epi16(psi_a_m7_m7, ONE_OVER_SQRT_2); - psi_a_m7_m7 = simde_mm_slli_epi16(psi_a_m7_m7, 2); - - // Calculation of a group of two terms in the bit metric involving squares of interference - simde__m128i a_sq_p7_p7 = square_a_64qam_epi16(a_r_p7_p7, a_i_p7_p7, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_p7_p5 = square_a_64qam_epi16(a_r_p7_p5, a_i_p7_p5, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_p7_p3 = square_a_64qam_epi16(a_r_p7_p3, a_i_p7_p3, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_p7_p1 = square_a_64qam_epi16(a_r_p7_p1, a_i_p7_p1, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_p7_m1 = square_a_64qam_epi16(a_r_p7_m1, a_i_p7_m1, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_p7_m3 = square_a_64qam_epi16(a_r_p7_m3, a_i_p7_m3, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_p7_m5 = square_a_64qam_epi16(a_r_p7_m5, a_i_p7_m5, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_p7_m7 = square_a_64qam_epi16(a_r_p7_m7, a_i_p7_m7, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_p5_p7 = square_a_64qam_epi16(a_r_p5_p7, a_i_p5_p7, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_p5_p5 = square_a_64qam_epi16(a_r_p5_p5, a_i_p5_p5, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_p5_p3 = square_a_64qam_epi16(a_r_p5_p3, a_i_p5_p3, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_p5_p1 = square_a_64qam_epi16(a_r_p5_p1, a_i_p5_p1, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_p5_m1 = square_a_64qam_epi16(a_r_p5_m1, a_i_p5_m1, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_p5_m3 = square_a_64qam_epi16(a_r_p5_m3, a_i_p5_m3, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_p5_m5 = square_a_64qam_epi16(a_r_p5_m5, a_i_p5_m5, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_p5_m7 = square_a_64qam_epi16(a_r_p5_m7, a_i_p5_m7, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_p3_p7 = square_a_64qam_epi16(a_r_p3_p7, a_i_p3_p7, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_p3_p5 = square_a_64qam_epi16(a_r_p3_p5, a_i_p3_p5, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_p3_p3 = square_a_64qam_epi16(a_r_p3_p3, a_i_p3_p3, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_p3_p1 = square_a_64qam_epi16(a_r_p3_p1, a_i_p3_p1, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_p3_m1 = square_a_64qam_epi16(a_r_p3_m1, a_i_p3_m1, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_p3_m3 = square_a_64qam_epi16(a_r_p3_m3, a_i_p3_m3, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_p3_m5 = square_a_64qam_epi16(a_r_p3_m5, a_i_p3_m5, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_p3_m7 = square_a_64qam_epi16(a_r_p3_m7, a_i_p3_m7, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_p1_p7 = square_a_64qam_epi16(a_r_p1_p7, a_i_p1_p7, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_p1_p5 = square_a_64qam_epi16(a_r_p1_p5, a_i_p1_p5, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_p1_p3 = square_a_64qam_epi16(a_r_p1_p3, a_i_p1_p3, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_p1_p1 = square_a_64qam_epi16(a_r_p1_p1, a_i_p1_p1, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_p1_m1 = square_a_64qam_epi16(a_r_p1_m1, a_i_p1_m1, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_p1_m3 = square_a_64qam_epi16(a_r_p1_m3, a_i_p1_m3, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_p1_m5 = square_a_64qam_epi16(a_r_p1_m5, a_i_p1_m5, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_p1_m7 = square_a_64qam_epi16(a_r_p1_m7, a_i_p1_m7, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_m1_p7 = square_a_64qam_epi16(a_r_m1_p7, a_i_m1_p7, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_m1_p5 = square_a_64qam_epi16(a_r_m1_p5, a_i_m1_p5, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_m1_p3 = square_a_64qam_epi16(a_r_m1_p3, a_i_m1_p3, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_m1_p1 = square_a_64qam_epi16(a_r_m1_p1, a_i_m1_p1, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_m1_m1 = square_a_64qam_epi16(a_r_m1_m1, a_i_m1_m1, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_m1_m3 = square_a_64qam_epi16(a_r_m1_m3, a_i_m1_m3, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_m1_m5 = square_a_64qam_epi16(a_r_m1_m5, a_i_m1_m5, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_m1_m7 = square_a_64qam_epi16(a_r_m1_m7, a_i_m1_m7, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_m3_p7 = square_a_64qam_epi16(a_r_m3_p7, a_i_m3_p7, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_m3_p5 = square_a_64qam_epi16(a_r_m3_p5, a_i_m3_p5, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_m3_p3 = square_a_64qam_epi16(a_r_m3_p3, a_i_m3_p3, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_m3_p1 = square_a_64qam_epi16(a_r_m3_p1, a_i_m3_p1, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_m3_m1 = square_a_64qam_epi16(a_r_m3_m1, a_i_m3_m1, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_m3_m3 = square_a_64qam_epi16(a_r_m3_m3, a_i_m3_m3, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_m3_m5 = square_a_64qam_epi16(a_r_m3_m5, a_i_m3_m5, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_m3_m7 = square_a_64qam_epi16(a_r_m3_m7, a_i_m3_m7, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_m5_p7 = square_a_64qam_epi16(a_r_m5_p7, a_i_m5_p7, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_m5_p5 = square_a_64qam_epi16(a_r_m5_p5, a_i_m5_p5, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_m5_p3 = square_a_64qam_epi16(a_r_m5_p3, a_i_m5_p3, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_m5_p1 = square_a_64qam_epi16(a_r_m5_p1, a_i_m5_p1, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_m5_m1 = square_a_64qam_epi16(a_r_m5_m1, a_i_m5_m1, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_m5_m3 = square_a_64qam_epi16(a_r_m5_m3, a_i_m5_m3, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_m5_m5 = square_a_64qam_epi16(a_r_m5_m5, a_i_m5_m5, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_m5_m7 = square_a_64qam_epi16(a_r_m5_m7, a_i_m5_m7, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_m7_p7 = square_a_64qam_epi16(a_r_m7_p7, a_i_m7_p7, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_m7_p5 = square_a_64qam_epi16(a_r_m7_p5, a_i_m7_p5, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_m7_p3 = square_a_64qam_epi16(a_r_m7_p3, a_i_m7_p3, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_m7_p1 = square_a_64qam_epi16(a_r_m7_p1, a_i_m7_p1, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_m7_m1 = square_a_64qam_epi16(a_r_m7_m1, a_i_m7_m1, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_m7_m3 = square_a_64qam_epi16(a_r_m7_m3, a_i_m7_m3, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_m7_m5 = square_a_64qam_epi16(a_r_m7_m5, a_i_m7_m5, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m128i a_sq_m7_m7 = square_a_64qam_epi16(a_r_m7_m7, a_i_m7_m7, ch_mag_int, SQRT_42_OVER_FOUR); + // Calculation of a group of two terms in the bit metric involving squares of interference + a_sq_s[j] = square_a_64qam_epi16(a_r_s[j], a_i_s[j], ch_mag_int, SQRT_42_OVER_FOUR); + } // Computing different multiples of ||h0||^2 // x=1, y=1 @@ -3162,603 +1634,292 @@ void nr_ulsch_qam64_qam64(c16_t *stream0_in, ch_mag_98_over_42_with_sigma2 = simde_mm_slli_epi16(ch_mag_98_over_42_with_sigma2, 2); // Computing Metrics - xmm0 = simde_mm_subs_epi16(psi_a_p7_p7, a_sq_p7_p7); - simde__m128i xmm1 = simde_mm_adds_epi16(xmm0, y0_p_7_7); - simde__m128i bit_met_p7_p7 = simde_mm_subs_epi16(xmm1, ch_mag_98_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_p7_p5, a_sq_p7_p5); - xmm1 = simde_mm_adds_epi16(xmm0, y0_p_7_5); - simde__m128i bit_met_p7_p5 = simde_mm_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_p7_p3, a_sq_p7_p3); - xmm1 = simde_mm_adds_epi16(xmm0, y0_p_7_3); - simde__m128i bit_met_p7_p3 = simde_mm_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_p7_p1, a_sq_p7_p1); - xmm1 = simde_mm_adds_epi16(xmm0, y0_p_7_1); - simde__m128i bit_met_p7_p1 = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_p7_m1, a_sq_p7_m1); - xmm1 = simde_mm_adds_epi16(xmm0, y0_m_7_1); - simde__m128i bit_met_p7_m1 = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_p7_m3, a_sq_p7_m3); - xmm1 = simde_mm_adds_epi16(xmm0, y0_m_7_3); - simde__m128i bit_met_p7_m3 = simde_mm_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_p7_m5, a_sq_p7_m5); - xmm1 = simde_mm_adds_epi16(xmm0, y0_m_7_5); - simde__m128i bit_met_p7_m5 = simde_mm_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_p7_m7, a_sq_p7_m7); - xmm1 = simde_mm_adds_epi16(xmm0, y0_m_7_7); - simde__m128i bit_met_p7_m7 = simde_mm_subs_epi16(xmm1, ch_mag_98_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_p5_p7, a_sq_p5_p7); - xmm1 = simde_mm_adds_epi16(xmm0, y0_p_5_7); - simde__m128i bit_met_p5_p7 = simde_mm_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_p5_p5, a_sq_p5_p5); - xmm1 = simde_mm_adds_epi16(xmm0, y0_p_5_5); - simde__m128i bit_met_p5_p5 = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_p5_p3, a_sq_p5_p3); - xmm1 = simde_mm_adds_epi16(xmm0, y0_p_5_3); - simde__m128i bit_met_p5_p3 = simde_mm_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_p5_p1, a_sq_p5_p1); - xmm1 = simde_mm_adds_epi16(xmm0, y0_p_5_1); - simde__m128i bit_met_p5_p1 = simde_mm_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_p5_m1, a_sq_p5_m1); - xmm1 = simde_mm_adds_epi16(xmm0, y0_m_5_1); - simde__m128i bit_met_p5_m1 = simde_mm_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_p5_m3, a_sq_p5_m3); - xmm1 = simde_mm_adds_epi16(xmm0, y0_m_5_3); - simde__m128i bit_met_p5_m3 = simde_mm_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_p5_m5, a_sq_p5_m5); - xmm1 = simde_mm_adds_epi16(xmm0, y0_m_5_5); - simde__m128i bit_met_p5_m5 = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_p5_m7, a_sq_p5_m7); - xmm1 = simde_mm_adds_epi16(xmm0, y0_m_5_7); - simde__m128i bit_met_p5_m7 = simde_mm_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_p3_p7, a_sq_p3_p7); - xmm1 = simde_mm_adds_epi16(xmm0, y0_p_3_7); - simde__m128i bit_met_p3_p7 = simde_mm_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_p3_p5, a_sq_p3_p5); - xmm1 = simde_mm_adds_epi16(xmm0, y0_p_3_5); - simde__m128i bit_met_p3_p5 = simde_mm_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_p3_p3, a_sq_p3_p3); - xmm1 = simde_mm_adds_epi16(xmm0, y0_p_3_3); - simde__m128i bit_met_p3_p3 = simde_mm_subs_epi16(xmm1, ch_mag_18_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_p3_p1, a_sq_p3_p1); - xmm1 = simde_mm_adds_epi16(xmm0, y0_p_3_1); - simde__m128i bit_met_p3_p1 = simde_mm_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_p3_m1, a_sq_p3_m1); - xmm1 = simde_mm_adds_epi16(xmm0, y0_m_3_1); - simde__m128i bit_met_p3_m1 = simde_mm_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_p3_m3, a_sq_p3_m3); - xmm1 = simde_mm_adds_epi16(xmm0, y0_m_3_3); - simde__m128i bit_met_p3_m3 = simde_mm_subs_epi16(xmm1, ch_mag_18_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_p3_m5, a_sq_p3_m5); - xmm1 = simde_mm_adds_epi16(xmm0, y0_m_3_5); - simde__m128i bit_met_p3_m5 = simde_mm_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_p3_m7, a_sq_p3_m7); - xmm1 = simde_mm_adds_epi16(xmm0, y0_m_3_7); - simde__m128i bit_met_p3_m7 = simde_mm_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_p1_p7, a_sq_p1_p7); - xmm1 = simde_mm_adds_epi16(xmm0, y0_p_1_7); - simde__m128i bit_met_p1_p7 = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_p1_p5, a_sq_p1_p5); - xmm1 = simde_mm_adds_epi16(xmm0, y0_p_1_5); - simde__m128i bit_met_p1_p5 = simde_mm_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_p1_p3, a_sq_p1_p3); - xmm1 = simde_mm_adds_epi16(xmm0, y0_p_1_3); - simde__m128i bit_met_p1_p3 = simde_mm_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_p1_p1, a_sq_p1_p1); - xmm1 = simde_mm_adds_epi16(xmm0, y0_p_1_1); - simde__m128i bit_met_p1_p1 = simde_mm_subs_epi16(xmm1, ch_mag_2_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_p1_m1, a_sq_p1_m1); - xmm1 = simde_mm_adds_epi16(xmm0, y0_m_1_1); - simde__m128i bit_met_p1_m1 = simde_mm_subs_epi16(xmm1, ch_mag_2_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_p1_m3, a_sq_p1_m3); - xmm1 = simde_mm_adds_epi16(xmm0, y0_m_1_3); - simde__m128i bit_met_p1_m3 = simde_mm_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_p1_m5, a_sq_p1_m5); - xmm1 = simde_mm_adds_epi16(xmm0, y0_m_1_5); - simde__m128i bit_met_p1_m5 = simde_mm_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_p1_m7, a_sq_p1_m7); - xmm1 = simde_mm_adds_epi16(xmm0, y0_m_1_7); - simde__m128i bit_met_p1_m7 = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + simde__m128i bit_met_s[64] __attribute__((aligned(16))); + xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[0], a_sq_s[0]), y0_s[0]); + bit_met_s[0] = simde_mm_subs_epi16(xmm1, ch_mag_98_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_m1_p7, a_sq_m1_p7); - xmm1 = simde_mm_subs_epi16(xmm0, y0_m_1_7); - simde__m128i bit_met_m1_p7 = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_m1_p5, a_sq_m1_p5); - xmm1 = simde_mm_subs_epi16(xmm0, y0_m_1_5); - simde__m128i bit_met_m1_p5 = simde_mm_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_m1_p3, a_sq_m1_p3); - xmm1 = simde_mm_subs_epi16(xmm0, y0_m_1_3); - simde__m128i bit_met_m1_p3 = simde_mm_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_m1_p1, a_sq_m1_p1); - xmm1 = simde_mm_subs_epi16(xmm0, y0_m_1_1); - simde__m128i bit_met_m1_p1 = simde_mm_subs_epi16(xmm1, ch_mag_2_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_m1_m1, a_sq_m1_m1); - xmm1 = simde_mm_subs_epi16(xmm0, y0_p_1_1); - simde__m128i bit_met_m1_m1 = simde_mm_subs_epi16(xmm1, ch_mag_2_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_m1_m3, a_sq_m1_m3); - xmm1 = simde_mm_subs_epi16(xmm0, y0_p_1_3); - simde__m128i bit_met_m1_m3 = simde_mm_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_m1_m5, a_sq_m1_m5); - xmm1 = simde_mm_subs_epi16(xmm0, y0_p_1_5); - simde__m128i bit_met_m1_m5 = simde_mm_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_m1_m7, a_sq_m1_m7); - xmm1 = simde_mm_subs_epi16(xmm0, y0_p_1_7); - simde__m128i bit_met_m1_m7 = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_m3_p7, a_sq_m3_p7); - xmm1 = simde_mm_subs_epi16(xmm0, y0_m_3_7); - simde__m128i bit_met_m3_p7 = simde_mm_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_m3_p5, a_sq_m3_p5); - xmm1 = simde_mm_subs_epi16(xmm0, y0_m_3_5); - simde__m128i bit_met_m3_p5 = simde_mm_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_m3_p3, a_sq_m3_p3); - xmm1 = simde_mm_subs_epi16(xmm0, y0_m_3_3); - simde__m128i bit_met_m3_p3 = simde_mm_subs_epi16(xmm1, ch_mag_18_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_m3_p1, a_sq_m3_p1); - xmm1 = simde_mm_subs_epi16(xmm0, y0_m_3_1); - simde__m128i bit_met_m3_p1 = simde_mm_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_m3_m1, a_sq_m3_m1); - xmm1 = simde_mm_subs_epi16(xmm0, y0_p_3_1); - simde__m128i bit_met_m3_m1 = simde_mm_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_m3_m3, a_sq_m3_m3); - xmm1 = simde_mm_subs_epi16(xmm0, y0_p_3_3); - simde__m128i bit_met_m3_m3 = simde_mm_subs_epi16(xmm1, ch_mag_18_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_m3_m5, a_sq_m3_m5); - xmm1 = simde_mm_subs_epi16(xmm0, y0_p_3_5); - simde__m128i bit_met_m3_m5 = simde_mm_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_m3_m7, a_sq_m3_m7); - xmm1 = simde_mm_subs_epi16(xmm0, y0_p_3_7); - simde__m128i bit_met_m3_m7 = simde_mm_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_m5_p7, a_sq_m5_p7); - xmm1 = simde_mm_subs_epi16(xmm0, y0_m_5_7); - simde__m128i bit_met_m5_p7 = simde_mm_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_m5_p5, a_sq_m5_p5); - xmm1 = simde_mm_subs_epi16(xmm0, y0_m_5_5); - simde__m128i bit_met_m5_p5 = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_m5_p3, a_sq_m5_p3); - xmm1 = simde_mm_subs_epi16(xmm0, y0_m_5_3); - simde__m128i bit_met_m5_p3 = simde_mm_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_m5_p1, a_sq_m5_p1); - xmm1 = simde_mm_subs_epi16(xmm0, y0_m_5_1); - simde__m128i bit_met_m5_p1 = simde_mm_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_m5_m1, a_sq_m5_m1); - xmm1 = simde_mm_subs_epi16(xmm0, y0_p_5_1); - simde__m128i bit_met_m5_m1 = simde_mm_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_m5_m3, a_sq_m5_m3); - xmm1 = simde_mm_subs_epi16(xmm0, y0_p_5_3); - simde__m128i bit_met_m5_m3 = simde_mm_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_m5_m5, a_sq_m5_m5); - xmm1 = simde_mm_subs_epi16(xmm0, y0_p_5_5); - simde__m128i bit_met_m5_m5 = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_m5_m7, a_sq_m5_m7); - xmm1 = simde_mm_subs_epi16(xmm0, y0_p_5_7); - simde__m128i bit_met_m5_m7 = simde_mm_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_m7_p7, a_sq_m7_p7); - xmm1 = simde_mm_subs_epi16(xmm0, y0_m_7_7); - simde__m128i bit_met_m7_p7 = simde_mm_subs_epi16(xmm1, ch_mag_98_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_m7_p5, a_sq_m7_p5); - xmm1 = simde_mm_subs_epi16(xmm0, y0_m_7_5); - simde__m128i bit_met_m7_p5 = simde_mm_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_m7_p3, a_sq_m7_p3); - xmm1 = simde_mm_subs_epi16(xmm0, y0_m_7_3); - simde__m128i bit_met_m7_p3 = simde_mm_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_m7_p1, a_sq_m7_p1); - xmm1 = simde_mm_subs_epi16(xmm0, y0_m_7_1); - simde__m128i bit_met_m7_p1 = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_m7_m1, a_sq_m7_m1); - xmm1 = simde_mm_subs_epi16(xmm0, y0_p_7_1); - simde__m128i bit_met_m7_m1 = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_m7_m3, a_sq_m7_m3); - xmm1 = simde_mm_subs_epi16(xmm0, y0_p_7_3); - simde__m128i bit_met_m7_m3 = simde_mm_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_m7_m5, a_sq_m7_m5); - xmm1 = simde_mm_subs_epi16(xmm0, y0_p_7_5); - simde__m128i bit_met_m7_m5 = simde_mm_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); - xmm0 = simde_mm_subs_epi16(psi_a_m7_m7, a_sq_m7_m7); - xmm1 = simde_mm_subs_epi16(xmm0, y0_p_7_7); - simde__m128i bit_met_m7_m7 = simde_mm_subs_epi16(xmm1, ch_mag_98_over_42_with_sigma2); + xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[1], a_sq_s[1]), y0_s[1]); + bit_met_s[1] = simde_mm_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); + xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[2], a_sq_s[2]), y0_s[2]); + bit_met_s[2] = simde_mm_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); + + xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[3], a_sq_s[3]), y0_s[3]); + bit_met_s[3] = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + + xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[4], a_sq_s[4]), y0_s[4]); + bit_met_s[4] = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + + xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[5], a_sq_s[5]), y0_s[5]); + bit_met_s[5] = simde_mm_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); + + xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[6], a_sq_s[6]), y0_s[6]); + bit_met_s[6] = simde_mm_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); + + xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[7], a_sq_s[7]), y0_s[7]); + bit_met_s[7] = simde_mm_subs_epi16(xmm1, ch_mag_98_over_42_with_sigma2); + + xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[8], a_sq_s[8]), y0_s[8]); + bit_met_s[8] = simde_mm_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); + + xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[9], a_sq_s[9]), y0_s[9]); + bit_met_s[9] = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + + xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[10], a_sq_s[10]), y0_s[10]); + bit_met_s[10] = simde_mm_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); + + xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[11], a_sq_s[11]), y0_s[11]); + bit_met_s[11] = simde_mm_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); + + xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[12], a_sq_s[12]), y0_s[12]); + bit_met_s[12] = simde_mm_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); + + xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[13], a_sq_s[13]), y0_s[13]); + bit_met_s[13] = simde_mm_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); + + xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[14], a_sq_s[14]), y0_s[14]); + bit_met_s[14] = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + + xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[15], a_sq_s[15]), y0_s[15]); + bit_met_s[15] = simde_mm_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); + + xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[16], a_sq_s[16]), y0_s[16]); + bit_met_s[16] = simde_mm_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); + + xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[17], a_sq_s[17]), y0_s[17]); + bit_met_s[17] = simde_mm_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); + + xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[18], a_sq_s[18]), y0_s[18]); + bit_met_s[18] = simde_mm_subs_epi16(xmm1, ch_mag_18_over_42_with_sigma2); + + xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[19], a_sq_s[19]), y0_s[19]); + bit_met_s[19] = simde_mm_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); + + xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[20], a_sq_s[20]), y0_s[20]); + bit_met_s[20] = simde_mm_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); + + xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[21], a_sq_s[21]), y0_s[21]); + bit_met_s[21] = simde_mm_subs_epi16(xmm1, ch_mag_18_over_42_with_sigma2); + + xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[22], a_sq_s[22]), y0_s[22]); + bit_met_s[22] = simde_mm_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); + + xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[23], a_sq_s[23]), y0_s[23]); + bit_met_s[23] = simde_mm_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); + + xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[24], a_sq_s[24]), y0_s[24]); + bit_met_s[24] = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + + xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[25], a_sq_s[25]), y0_s[25]); + bit_met_s[25] = simde_mm_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); + + xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[26], a_sq_s[26]), y0_s[26]); + bit_met_s[26] = simde_mm_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); + + xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[27], a_sq_s[27]), y0_s[27]); + bit_met_s[27] = simde_mm_subs_epi16(xmm1, ch_mag_2_over_42_with_sigma2); + + xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[28], a_sq_s[28]), y0_s[28]); + bit_met_s[28] = simde_mm_subs_epi16(xmm1, ch_mag_2_over_42_with_sigma2); + + xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[29], a_sq_s[29]), y0_s[29]); + bit_met_s[29] = simde_mm_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); + + xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[30], a_sq_s[30]), y0_s[30]); + bit_met_s[30] = simde_mm_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); + + xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[31], a_sq_s[31]), y0_s[31]); + bit_met_s[31] = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[32], a_sq_s[32]), y0_s[31]); + bit_met_s[32] = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + + xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[33], a_sq_s[33]), y0_s[30]); + bit_met_s[33] = simde_mm_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); + + xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[34], a_sq_s[34]), y0_s[29]); + bit_met_s[34] = simde_mm_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); + + xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[35], a_sq_s[35]), y0_s[28]); + bit_met_s[35] = simde_mm_subs_epi16(xmm1, ch_mag_2_over_42_with_sigma2); + + xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[36], a_sq_s[36]), y0_s[27]); + bit_met_s[36] = simde_mm_subs_epi16(xmm1, ch_mag_2_over_42_with_sigma2); + + xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[37], a_sq_s[37]), y0_s[26]); + bit_met_s[37] = simde_mm_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); + + xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[38], a_sq_s[38]), y0_s[25]); + bit_met_s[38] = simde_mm_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); + + xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[39], a_sq_s[39]), y0_s[24]); + bit_met_s[39] = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + + xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[40], a_sq_s[40]), y0_s[23]); + bit_met_s[40] = simde_mm_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); + + xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[41], a_sq_s[41]), y0_s[22]); + bit_met_s[41] = simde_mm_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); + + xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[42], a_sq_s[42]), y0_s[21]); + bit_met_s[42] = simde_mm_subs_epi16(xmm1, ch_mag_18_over_42_with_sigma2); + + xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[43], a_sq_s[43]), y0_s[20]); + bit_met_s[43] = simde_mm_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); + + xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[44], a_sq_s[44]), y0_s[19]); + bit_met_s[44] = simde_mm_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); + + xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[45], a_sq_s[45]), y0_s[18]); + bit_met_s[45] = simde_mm_subs_epi16(xmm1, ch_mag_18_over_42_with_sigma2); + + xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[46], a_sq_s[46]), y0_s[17]); + bit_met_s[46] = simde_mm_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); + + xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[47], a_sq_s[47]), y0_s[16]); + bit_met_s[47] = simde_mm_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); + + xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[48], a_sq_s[48]), y0_s[15]); + bit_met_s[48] = simde_mm_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); + + xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[49], a_sq_s[49]), y0_s[14]); + bit_met_s[49] = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + + xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[50], a_sq_s[50]), y0_s[13]); + bit_met_s[50] = simde_mm_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); + + xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[51], a_sq_s[51]), y0_s[12]); + bit_met_s[51] = simde_mm_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); + + xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[52], a_sq_s[52]), y0_s[11]); + bit_met_s[52] = simde_mm_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); + + xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[53], a_sq_s[53]), y0_s[10]); + bit_met_s[53] = simde_mm_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); + + xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[54], a_sq_s[54]), y0_s[9]); + bit_met_s[54] = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + + xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[55], a_sq_s[55]), y0_s[8]); + bit_met_s[55] = simde_mm_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); + + xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[56], a_sq_s[56]), y0_s[7]); + bit_met_s[56] = simde_mm_subs_epi16(xmm1, ch_mag_98_over_42_with_sigma2); + + xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[57], a_sq_s[57]), y0_s[6]); + bit_met_s[57] = simde_mm_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); + + xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[58], a_sq_s[58]), y0_s[5]); + bit_met_s[58] = simde_mm_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); + + xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[59], a_sq_s[59]), y0_s[4]); + bit_met_s[59] = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + + xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[60], a_sq_s[60]), y0_s[3]); + bit_met_s[60] = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + + xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[61], a_sq_s[61]), y0_s[2]); + bit_met_s[61] = simde_mm_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); + + xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[62], a_sq_s[62]), y0_s[1]); + bit_met_s[62] = simde_mm_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); + + xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[63], a_sq_s[63]), y0_s[0]); + bit_met_s[63] = simde_mm_subs_epi16(xmm1, ch_mag_98_over_42_with_sigma2); + + // Detection for bits + simde__m128i logmax_den_re0; + simde__m128i logmax_num_re0; // Detection for 1st bit // bit = 1 - xmm0 = simde_mm_max_epi16(bit_met_m7_p7, bit_met_m7_p5); - xmm1 = simde_mm_max_epi16(bit_met_m7_p3, bit_met_m7_p1); - xmm2 = simde_mm_max_epi16(bit_met_m7_m1, bit_met_m7_m3); - xmm3 = simde_mm_max_epi16(bit_met_m7_m5, bit_met_m7_m7); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - simde__m128i logmax_den_re0 = simde_mm_max_epi16(xmm4, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_m5_p7, bit_met_m5_p5); - xmm1 = simde_mm_max_epi16(bit_met_m5_p3, bit_met_m5_p1); - xmm2 = simde_mm_max_epi16(bit_met_m5_m1, bit_met_m5_m3); - xmm3 = simde_mm_max_epi16(bit_met_m5_m5, bit_met_m5_m7); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_m3_p7, bit_met_m3_p5); - xmm1 = simde_mm_max_epi16(bit_met_m3_p3, bit_met_m3_p1); - xmm2 = simde_mm_max_epi16(bit_met_m3_m1, bit_met_m3_m3); - xmm3 = simde_mm_max_epi16(bit_met_m3_m5, bit_met_m3_m7); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_m1_p7, bit_met_m1_p5); - xmm1 = simde_mm_max_epi16(bit_met_m1_p3, bit_met_m1_p1); - xmm2 = simde_mm_max_epi16(bit_met_m1_m1, bit_met_m1_m3); - xmm3 = simde_mm_max_epi16(bit_met_m1_m5, bit_met_m1_m7); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); + xmm0 = max_epi16(bit_met_s[56],bit_met_s[57],bit_met_s[58],bit_met_s[59],bit_met_s[60],bit_met_s[61],bit_met_s[62],bit_met_s[63]); + xmm1 = max_epi16(bit_met_s[48],bit_met_s[49],bit_met_s[50],bit_met_s[51],bit_met_s[52],bit_met_s[53],bit_met_s[54],bit_met_s[55]); + xmm2 = max_epi16(bit_met_s[40],bit_met_s[41],bit_met_s[42],bit_met_s[43],bit_met_s[44],bit_met_s[45],bit_met_s[46],bit_met_s[47]); + xmm3 = max_epi16(bit_met_s[32],bit_met_s[33],bit_met_s[34],bit_met_s[35],bit_met_s[36],bit_met_s[37],bit_met_s[38],bit_met_s[39]); + logmax_den_re0 = simde_mm_max_epi16(simde_mm_max_epi16(xmm0, xmm1), simde_mm_max_epi16(xmm2, xmm3)); // bit = 0 - xmm0 = simde_mm_max_epi16(bit_met_p7_p7, bit_met_p7_p5); - xmm1 = simde_mm_max_epi16(bit_met_p7_p3, bit_met_p7_p1); - xmm2 = simde_mm_max_epi16(bit_met_p7_m1, bit_met_p7_m3); - xmm3 = simde_mm_max_epi16(bit_met_p7_m5, bit_met_p7_m7); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - simde__m128i logmax_num_re0 = simde_mm_max_epi16(xmm4, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_p5_p7, bit_met_p5_p5); - xmm1 = simde_mm_max_epi16(bit_met_p5_p3, bit_met_p5_p1); - xmm2 = simde_mm_max_epi16(bit_met_p5_m1, bit_met_p5_m3); - xmm3 = simde_mm_max_epi16(bit_met_p5_m5, bit_met_p5_m7); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_p3_p7, bit_met_p3_p5); - xmm1 = simde_mm_max_epi16(bit_met_p3_p3, bit_met_p3_p1); - xmm2 = simde_mm_max_epi16(bit_met_p3_m1, bit_met_p3_m3); - xmm3 = simde_mm_max_epi16(bit_met_p3_m5, bit_met_p3_m7); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_p1_p7, bit_met_p1_p5); - xmm1 = simde_mm_max_epi16(bit_met_p1_p3, bit_met_p1_p1); - xmm2 = simde_mm_max_epi16(bit_met_p1_m1, bit_met_p1_m3); - xmm3 = simde_mm_max_epi16(bit_met_p1_m5, bit_met_p1_m7); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); + xmm0 = max_epi16(bit_met_s[0],bit_met_s[1],bit_met_s[2],bit_met_s[3],bit_met_s[4],bit_met_s[5],bit_met_s[6],bit_met_s[7]); + xmm1 = max_epi16(bit_met_s[8],bit_met_s[9],bit_met_s[10],bit_met_s[11],bit_met_s[12],bit_met_s[13],bit_met_s[14],bit_met_s[15]); + xmm2 = max_epi16(bit_met_s[16],bit_met_s[17],bit_met_s[18],bit_met_s[19],bit_met_s[20],bit_met_s[21],bit_met_s[22],bit_met_s[23]); + xmm3 = max_epi16(bit_met_s[24],bit_met_s[25],bit_met_s[26],bit_met_s[27],bit_met_s[28],bit_met_s[29],bit_met_s[30],bit_met_s[31]); + logmax_num_re0 = simde_mm_max_epi16(simde_mm_max_epi16(xmm0, xmm1), simde_mm_max_epi16(xmm2, xmm3)); y0r = simde_mm_subs_epi16(logmax_num_re0, logmax_den_re0); // Detection for 2nd bit // bit = 1 - xmm0 = simde_mm_max_epi16(bit_met_p7_m1, bit_met_p5_m1); - xmm1 = simde_mm_max_epi16(bit_met_p3_m1, bit_met_p1_m1); - xmm2 = simde_mm_max_epi16(bit_met_m1_m1, bit_met_m3_m1); - xmm3 = simde_mm_max_epi16(bit_met_m5_m1, bit_met_m7_m1); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm_max_epi16(xmm4, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_p7_m3, bit_met_p5_m3); - xmm1 = simde_mm_max_epi16(bit_met_p3_m3, bit_met_p1_m3); - xmm2 = simde_mm_max_epi16(bit_met_m1_m3, bit_met_m3_m3); - xmm3 = simde_mm_max_epi16(bit_met_m5_m3, bit_met_m7_m3); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_p7_m5, bit_met_p5_m5); - xmm1 = simde_mm_max_epi16(bit_met_p3_m5, bit_met_p1_m5); - xmm2 = simde_mm_max_epi16(bit_met_m1_m5, bit_met_m3_m5); - xmm3 = simde_mm_max_epi16(bit_met_m5_m5, bit_met_m7_m5); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_p7_m7, bit_met_p5_m7); - xmm1 = simde_mm_max_epi16(bit_met_p3_m7, bit_met_p1_m7); - xmm2 = simde_mm_max_epi16(bit_met_m1_m7, bit_met_m3_m7); - xmm3 = simde_mm_max_epi16(bit_met_m5_m7, bit_met_m7_m7); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); + xmm0 = max_epi16(bit_met_s[4],bit_met_s[12],bit_met_s[20],bit_met_s[28],bit_met_s[36],bit_met_s[44],bit_met_s[52],bit_met_s[60]); + xmm1 = max_epi16(bit_met_s[5],bit_met_s[13],bit_met_s[21],bit_met_s[29],bit_met_s[37],bit_met_s[45],bit_met_s[53],bit_met_s[61]); + xmm2 = max_epi16(bit_met_s[6],bit_met_s[14],bit_met_s[22],bit_met_s[30],bit_met_s[38],bit_met_s[46],bit_met_s[54],bit_met_s[62]); + xmm3 = max_epi16(bit_met_s[7],bit_met_s[15],bit_met_s[23],bit_met_s[31],bit_met_s[39],bit_met_s[47],bit_met_s[55],bit_met_s[63]); + logmax_den_re0 = simde_mm_max_epi16(simde_mm_max_epi16(xmm0, xmm1), simde_mm_max_epi16(xmm2, xmm3)); // bit = 0 - xmm0 = simde_mm_max_epi16(bit_met_p7_p1, bit_met_p5_p1); - xmm1 = simde_mm_max_epi16(bit_met_p3_p1, bit_met_p1_p1); - xmm2 = simde_mm_max_epi16(bit_met_m1_p1, bit_met_m3_p1); - xmm3 = simde_mm_max_epi16(bit_met_m5_p1, bit_met_m7_p1); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm_max_epi16(xmm4, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_p7_p3, bit_met_p5_p3); - xmm1 = simde_mm_max_epi16(bit_met_p3_p3, bit_met_p1_p3); - xmm2 = simde_mm_max_epi16(bit_met_m1_p3, bit_met_m3_p3); - xmm3 = simde_mm_max_epi16(bit_met_m5_p3, bit_met_m7_p3); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_p7_p5, bit_met_p5_p5); - xmm1 = simde_mm_max_epi16(bit_met_p3_p5, bit_met_p1_p5); - xmm2 = simde_mm_max_epi16(bit_met_m1_p5, bit_met_m3_p5); - xmm3 = simde_mm_max_epi16(bit_met_m5_p5, bit_met_m7_p5); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_p7_p7, bit_met_p5_p7); - xmm1 = simde_mm_max_epi16(bit_met_p3_p7, bit_met_p1_p7); - xmm2 = simde_mm_max_epi16(bit_met_m1_p7, bit_met_m3_p7); - xmm3 = simde_mm_max_epi16(bit_met_m5_p7, bit_met_m7_p7); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); + xmm0 = max_epi16(bit_met_s[3],bit_met_s[11],bit_met_s[19],bit_met_s[27],bit_met_s[35],bit_met_s[43],bit_met_s[51],bit_met_s[59]); + xmm1 = max_epi16(bit_met_s[2],bit_met_s[10],bit_met_s[18],bit_met_s[26],bit_met_s[34],bit_met_s[42],bit_met_s[50],bit_met_s[58]); + xmm2 = max_epi16(bit_met_s[1],bit_met_s[9],bit_met_s[17],bit_met_s[25],bit_met_s[33],bit_met_s[41],bit_met_s[49],bit_met_s[57]); + xmm3 = max_epi16(bit_met_s[0],bit_met_s[8],bit_met_s[16],bit_met_s[24],bit_met_s[32],bit_met_s[40],bit_met_s[48],bit_met_s[56]); + logmax_num_re0 = simde_mm_max_epi16(simde_mm_max_epi16(xmm0, xmm1), simde_mm_max_epi16(xmm2, xmm3)); y1r = simde_mm_subs_epi16(logmax_num_re0, logmax_den_re0); // Detection for 3rd bit - xmm0 = simde_mm_max_epi16(bit_met_m7_m7, bit_met_m7_m5); - xmm1 = simde_mm_max_epi16(bit_met_m7_m3, bit_met_m7_m1); - xmm2 = simde_mm_max_epi16(bit_met_m7_p1, bit_met_m7_p3); - xmm3 = simde_mm_max_epi16(bit_met_m7_p5, bit_met_m7_p7); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm_max_epi16(xmm4, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_m5_m7, bit_met_m5_m5); - xmm1 = simde_mm_max_epi16(bit_met_m5_m3, bit_met_m5_m1); - xmm2 = simde_mm_max_epi16(bit_met_m5_p1, bit_met_m5_p3); - xmm3 = simde_mm_max_epi16(bit_met_m5_p5, bit_met_m5_p7); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_p5_m7, bit_met_p5_m5); - xmm1 = simde_mm_max_epi16(bit_met_p5_m3, bit_met_p5_m1); - xmm2 = simde_mm_max_epi16(bit_met_p5_p1, bit_met_p5_p3); - xmm3 = simde_mm_max_epi16(bit_met_p5_p5, bit_met_p5_p7); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_p7_m7, bit_met_p7_m5); - xmm1 = simde_mm_max_epi16(bit_met_p7_m3, bit_met_p7_m1); - xmm2 = simde_mm_max_epi16(bit_met_p7_p1, bit_met_p7_p3); - xmm3 = simde_mm_max_epi16(bit_met_p7_p5, bit_met_p7_p7); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); + xmm0 = max_epi16(bit_met_s[63],bit_met_s[62],bit_met_s[61],bit_met_s[60],bit_met_s[59],bit_met_s[58],bit_met_s[57],bit_met_s[56]); + xmm1 = max_epi16(bit_met_s[55],bit_met_s[54],bit_met_s[53],bit_met_s[52],bit_met_s[51],bit_met_s[50],bit_met_s[49],bit_met_s[48]); + xmm2 = max_epi16(bit_met_s[15],bit_met_s[14],bit_met_s[13],bit_met_s[12],bit_met_s[11],bit_met_s[10],bit_met_s[9],bit_met_s[8]); + xmm3 = max_epi16(bit_met_s[7],bit_met_s[6],bit_met_s[5],bit_met_s[4],bit_met_s[3],bit_met_s[2],bit_met_s[1],bit_met_s[0]); + logmax_den_re0 = simde_mm_max_epi16(simde_mm_max_epi16(xmm0, xmm1), simde_mm_max_epi16(xmm2, xmm3)); - xmm0 = simde_mm_max_epi16(bit_met_m3_m7, bit_met_m3_m5); - xmm1 = simde_mm_max_epi16(bit_met_m3_m3, bit_met_m3_m1); - xmm2 = simde_mm_max_epi16(bit_met_m3_p1, bit_met_m3_p3); - xmm3 = simde_mm_max_epi16(bit_met_m3_p5, bit_met_m3_p7); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm_max_epi16(xmm4, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_m1_m7, bit_met_m1_m5); - xmm1 = simde_mm_max_epi16(bit_met_m1_m3, bit_met_m1_m1); - xmm2 = simde_mm_max_epi16(bit_met_m1_p1, bit_met_m1_p3); - xmm3 = simde_mm_max_epi16(bit_met_m1_p5, bit_met_m1_p7); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_p1_m7, bit_met_p1_m5); - xmm1 = simde_mm_max_epi16(bit_met_p1_m3, bit_met_p1_m1); - xmm2 = simde_mm_max_epi16(bit_met_p1_p1, bit_met_p1_p3); - xmm3 = simde_mm_max_epi16(bit_met_p1_p5, bit_met_p1_p7); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_p3_m7, bit_met_p3_m5); - xmm1 = simde_mm_max_epi16(bit_met_p3_m3, bit_met_p3_m1); - xmm2 = simde_mm_max_epi16(bit_met_p3_p1, bit_met_p3_p3); - xmm3 = simde_mm_max_epi16(bit_met_p3_p5, bit_met_p3_p7); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); + xmm0 = max_epi16(bit_met_s[47],bit_met_s[46],bit_met_s[45],bit_met_s[44],bit_met_s[43],bit_met_s[42],bit_met_s[41],bit_met_s[40]); + xmm1 = max_epi16(bit_met_s[39],bit_met_s[38],bit_met_s[37],bit_met_s[36],bit_met_s[35],bit_met_s[34],bit_met_s[33],bit_met_s[32]); + xmm2 = max_epi16(bit_met_s[31],bit_met_s[30],bit_met_s[29],bit_met_s[28],bit_met_s[27],bit_met_s[26],bit_met_s[25],bit_met_s[24]); + xmm3 = max_epi16(bit_met_s[23],bit_met_s[22],bit_met_s[21],bit_met_s[20],bit_met_s[19],bit_met_s[18],bit_met_s[17],bit_met_s[16]); + logmax_num_re0 = simde_mm_max_epi16(simde_mm_max_epi16(xmm0, xmm1), simde_mm_max_epi16(xmm2, xmm3)); simde__m128i y2r = simde_mm_subs_epi16(logmax_num_re0, logmax_den_re0); // Detection for 4th bit - xmm0 = simde_mm_max_epi16(bit_met_p7_p7, bit_met_p5_p7); - xmm1 = simde_mm_max_epi16(bit_met_p3_p7, bit_met_p1_p7); - xmm2 = simde_mm_max_epi16(bit_met_m1_p7, bit_met_m3_p7); - xmm3 = simde_mm_max_epi16(bit_met_m5_p7, bit_met_m7_p7); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm_max_epi16(xmm4, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_p7_p5, bit_met_p5_p5); - xmm1 = simde_mm_max_epi16(bit_met_p3_p5, bit_met_p1_p5); - xmm2 = simde_mm_max_epi16(bit_met_m1_p5, bit_met_m3_p5); - xmm3 = simde_mm_max_epi16(bit_met_m5_p5, bit_met_m5_p5); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_p7_m5, bit_met_p5_m5); - xmm1 = simde_mm_max_epi16(bit_met_p3_m5, bit_met_p1_m5); - xmm2 = simde_mm_max_epi16(bit_met_m1_m5, bit_met_m3_m5); - xmm3 = simde_mm_max_epi16(bit_met_m5_m5, bit_met_m7_m5); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_p7_m7, bit_met_p5_m7); - xmm1 = simde_mm_max_epi16(bit_met_p3_m7, bit_met_p1_m7); - xmm2 = simde_mm_max_epi16(bit_met_m1_m7, bit_met_m3_m7); - xmm3 = simde_mm_max_epi16(bit_met_m5_m7, bit_met_m7_m7); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); + xmm0 = max_epi16(bit_met_s[0],bit_met_s[8],bit_met_s[16],bit_met_s[24],bit_met_s[32],bit_met_s[40],bit_met_s[48],bit_met_s[56]); + xmm1 = max_epi16(bit_met_s[1],bit_met_s[9],bit_met_s[17],bit_met_s[25],bit_met_s[33],bit_met_s[41],bit_met_s[49],bit_met_s[49]); + xmm2 = max_epi16(bit_met_s[6],bit_met_s[14],bit_met_s[22],bit_met_s[30],bit_met_s[38],bit_met_s[46],bit_met_s[54],bit_met_s[62]); + xmm3 = max_epi16(bit_met_s[7],bit_met_s[15],bit_met_s[23],bit_met_s[31],bit_met_s[39],bit_met_s[47],bit_met_s[55],bit_met_s[63]); + logmax_den_re0 = simde_mm_max_epi16(simde_mm_max_epi16(xmm0, xmm1), simde_mm_max_epi16(xmm2, xmm3)); - xmm0 = simde_mm_max_epi16(bit_met_p7_m1, bit_met_p5_m1); - xmm1 = simde_mm_max_epi16(bit_met_p3_m1, bit_met_p1_m1); - xmm2 = simde_mm_max_epi16(bit_met_m1_m1, bit_met_m3_m1); - xmm3 = simde_mm_max_epi16(bit_met_m5_m1, bit_met_m7_m1); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm_max_epi16(xmm4, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_p7_m3, bit_met_p5_m3); - xmm1 = simde_mm_max_epi16(bit_met_p3_m3, bit_met_p1_m3); - xmm2 = simde_mm_max_epi16(bit_met_m1_m3, bit_met_m3_m3); - xmm3 = simde_mm_max_epi16(bit_met_m5_m3, bit_met_m7_m3); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_p7_p1, bit_met_p5_p1); - xmm1 = simde_mm_max_epi16(bit_met_p3_p1, bit_met_p1_p1); - xmm2 = simde_mm_max_epi16(bit_met_m1_p1, bit_met_m3_p1); - xmm3 = simde_mm_max_epi16(bit_met_m5_p1, bit_met_m7_p1); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_p7_p3, bit_met_p5_p3); - xmm1 = simde_mm_max_epi16(bit_met_p3_p3, bit_met_p1_p3); - xmm2 = simde_mm_max_epi16(bit_met_m1_p3, bit_met_m3_p3); - xmm3 = simde_mm_max_epi16(bit_met_m5_p3, bit_met_m7_p3); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); + xmm0 = max_epi16(bit_met_s[4],bit_met_s[12],bit_met_s[20],bit_met_s[28],bit_met_s[36],bit_met_s[44],bit_met_s[52],bit_met_s[60]); + xmm1 = max_epi16(bit_met_s[5],bit_met_s[13],bit_met_s[21],bit_met_s[29],bit_met_s[37],bit_met_s[45],bit_met_s[53],bit_met_s[61]); + xmm2 = max_epi16(bit_met_s[3],bit_met_s[11],bit_met_s[19],bit_met_s[27],bit_met_s[35],bit_met_s[43],bit_met_s[51],bit_met_s[59]); + xmm3 = max_epi16(bit_met_s[2],bit_met_s[10],bit_met_s[18],bit_met_s[26],bit_met_s[34],bit_met_s[42],bit_met_s[50],bit_met_s[58]); + logmax_num_re0 = simde_mm_max_epi16(simde_mm_max_epi16(xmm0, xmm1), simde_mm_max_epi16(xmm2, xmm3)); y0i = simde_mm_subs_epi16(logmax_num_re0, logmax_den_re0); // Detection for 5th bit - xmm0 = simde_mm_max_epi16(bit_met_m7_m7, bit_met_m7_m5); - xmm1 = simde_mm_max_epi16(bit_met_m7_m3, bit_met_m7_m1); - xmm2 = simde_mm_max_epi16(bit_met_m7_p1, bit_met_m7_p3); - xmm3 = simde_mm_max_epi16(bit_met_m7_p5, bit_met_m7_p7); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm_max_epi16(xmm4, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_m1_m7, bit_met_m1_m5); - xmm1 = simde_mm_max_epi16(bit_met_m1_m3, bit_met_m1_m1); - xmm2 = simde_mm_max_epi16(bit_met_m1_p1, bit_met_m1_p3); - xmm3 = simde_mm_max_epi16(bit_met_m1_p5, bit_met_m1_p7); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_p1_m7, bit_met_p1_m5); - xmm1 = simde_mm_max_epi16(bit_met_p1_m3, bit_met_p1_m1); - xmm2 = simde_mm_max_epi16(bit_met_p1_p1, bit_met_p1_p3); - xmm3 = simde_mm_max_epi16(bit_met_p1_p5, bit_met_p1_p7); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_p7_m7, bit_met_p7_m5); - xmm1 = simde_mm_max_epi16(bit_met_p7_m3, bit_met_p7_m1); - xmm2 = simde_mm_max_epi16(bit_met_p7_p1, bit_met_p7_p3); - xmm3 = simde_mm_max_epi16(bit_met_p7_p5, bit_met_p7_p7); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); + xmm0 = max_epi16(bit_met_s[63],bit_met_s[62],bit_met_s[61],bit_met_s[60],bit_met_s[59],bit_met_s[58],bit_met_s[57],bit_met_s[56]); + xmm1 = max_epi16(bit_met_s[39],bit_met_s[38],bit_met_s[37],bit_met_s[36],bit_met_s[35],bit_met_s[34],bit_met_s[33],bit_met_s[32]); + xmm2 = max_epi16(bit_met_s[31],bit_met_s[30],bit_met_s[29],bit_met_s[28],bit_met_s[27],bit_met_s[26],bit_met_s[25],bit_met_s[24]); + xmm3 = max_epi16(bit_met_s[7],bit_met_s[6],bit_met_s[5],bit_met_s[4],bit_met_s[3],bit_met_s[2],bit_met_s[1],bit_met_s[0]); + logmax_den_re0 = simde_mm_max_epi16(simde_mm_max_epi16(xmm0, xmm1), simde_mm_max_epi16(xmm2, xmm3)); - xmm0 = simde_mm_max_epi16(bit_met_m5_m7, bit_met_m5_m5); - xmm1 = simde_mm_max_epi16(bit_met_m5_m3, bit_met_m5_m1); - xmm2 = simde_mm_max_epi16(bit_met_m5_p1, bit_met_m5_p3); - xmm3 = simde_mm_max_epi16(bit_met_m5_p5, bit_met_m5_p7); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm_max_epi16(xmm4, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_m3_m7, bit_met_m3_m5); - xmm1 = simde_mm_max_epi16(bit_met_m3_m3, bit_met_m3_m1); - xmm2 = simde_mm_max_epi16(bit_met_m3_p1, bit_met_m3_p3); - xmm3 = simde_mm_max_epi16(bit_met_m3_p5, bit_met_m3_p7); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_p3_m7, bit_met_p3_m5); - xmm1 = simde_mm_max_epi16(bit_met_p3_m3, bit_met_p3_m1); - xmm2 = simde_mm_max_epi16(bit_met_p3_p1, bit_met_p3_p3); - xmm3 = simde_mm_max_epi16(bit_met_p3_p5, bit_met_p3_p7); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_p5_m7, bit_met_p5_m5); - xmm1 = simde_mm_max_epi16(bit_met_p5_m3, bit_met_p5_m1); - xmm2 = simde_mm_max_epi16(bit_met_p5_p1, bit_met_p5_p3); - xmm3 = simde_mm_max_epi16(bit_met_p5_p5, bit_met_p5_p7); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); + xmm0 = max_epi16(bit_met_s[55],bit_met_s[54],bit_met_s[53],bit_met_s[52],bit_met_s[51],bit_met_s[50],bit_met_s[49],bit_met_s[48]); + xmm1 = max_epi16(bit_met_s[47],bit_met_s[46],bit_met_s[45],bit_met_s[44],bit_met_s[43],bit_met_s[42],bit_met_s[41],bit_met_s[40]); + xmm2 = max_epi16(bit_met_s[23],bit_met_s[22],bit_met_s[21],bit_met_s[20],bit_met_s[19],bit_met_s[18],bit_met_s[17],bit_met_s[16]); + xmm3 = max_epi16(bit_met_s[15],bit_met_s[14],bit_met_s[13],bit_met_s[12],bit_met_s[11],bit_met_s[10],bit_met_s[9],bit_met_s[8]); + logmax_num_re0 = simde_mm_max_epi16(simde_mm_max_epi16(xmm0, xmm1), simde_mm_max_epi16(xmm2, xmm3)); y1i = simde_mm_subs_epi16(logmax_num_re0, logmax_den_re0); // Detection for 6th bit - xmm0 = simde_mm_max_epi16(bit_met_p7_p7, bit_met_p5_p7); - xmm1 = simde_mm_max_epi16(bit_met_p3_p7, bit_met_p1_p7); - xmm2 = simde_mm_max_epi16(bit_met_m1_p7, bit_met_m3_p7); - xmm3 = simde_mm_max_epi16(bit_met_m5_p7, bit_met_m7_p7); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm_max_epi16(xmm4, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_p7_p1, bit_met_p5_p1); - xmm1 = simde_mm_max_epi16(bit_met_p3_p1, bit_met_p1_p1); - xmm2 = simde_mm_max_epi16(bit_met_m1_p1, bit_met_m3_p1); - xmm3 = simde_mm_max_epi16(bit_met_m5_p1, bit_met_m5_p1); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_p7_m1, bit_met_p5_m1); - xmm1 = simde_mm_max_epi16(bit_met_p3_m1, bit_met_p1_m1); - xmm2 = simde_mm_max_epi16(bit_met_m1_m1, bit_met_m3_m1); - xmm3 = simde_mm_max_epi16(bit_met_m5_m1, bit_met_m7_m1); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_p7_m7, bit_met_p5_m7); - xmm1 = simde_mm_max_epi16(bit_met_p3_m7, bit_met_p1_m7); - xmm2 = simde_mm_max_epi16(bit_met_m1_m7, bit_met_m3_m7); - xmm3 = simde_mm_max_epi16(bit_met_m5_m7, bit_met_m7_m7); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm_max_epi16(logmax_den_re0, xmm5); + xmm0 = max_epi16(bit_met_s[0],bit_met_s[8],bit_met_s[16],bit_met_s[24],bit_met_s[32],bit_met_s[40],bit_met_s[48],bit_met_s[56]); + xmm1 = max_epi16(bit_met_s[3],bit_met_s[11],bit_met_s[19],bit_met_s[27],bit_met_s[35],bit_met_s[43],bit_met_s[51],bit_met_s[51]); + xmm2 = max_epi16(bit_met_s[4],bit_met_s[12],bit_met_s[20],bit_met_s[28],bit_met_s[36],bit_met_s[44],bit_met_s[52],bit_met_s[60]); + xmm3 = max_epi16(bit_met_s[7],bit_met_s[15],bit_met_s[23],bit_met_s[31],bit_met_s[39],bit_met_s[47],bit_met_s[55],bit_met_s[63]); + logmax_den_re0 = simde_mm_max_epi16(simde_mm_max_epi16(xmm0, xmm1), simde_mm_max_epi16(xmm2, xmm3)); - xmm0 = simde_mm_max_epi16(bit_met_p7_m5, bit_met_p5_m5); - xmm1 = simde_mm_max_epi16(bit_met_p3_m5, bit_met_p1_m5); - xmm2 = simde_mm_max_epi16(bit_met_m1_m5, bit_met_m3_m5); - xmm3 = simde_mm_max_epi16(bit_met_m5_m5, bit_met_m7_m5); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm_max_epi16(xmm4, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_p7_m3, bit_met_p5_m3); - xmm1 = simde_mm_max_epi16(bit_met_p3_m3, bit_met_p1_m3); - xmm2 = simde_mm_max_epi16(bit_met_m1_m3, bit_met_m3_m3); - xmm3 = simde_mm_max_epi16(bit_met_m5_m3, bit_met_m7_m3); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_p7_p3, bit_met_p5_p3); - xmm1 = simde_mm_max_epi16(bit_met_p3_p3, bit_met_p1_p3); - xmm2 = simde_mm_max_epi16(bit_met_m1_p3, bit_met_m3_p3); - xmm3 = simde_mm_max_epi16(bit_met_m5_p3, bit_met_m7_p3); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); - xmm0 = simde_mm_max_epi16(bit_met_p7_p5, bit_met_p5_p5); - xmm1 = simde_mm_max_epi16(bit_met_p3_p5, bit_met_p1_p5); - xmm2 = simde_mm_max_epi16(bit_met_m1_p5, bit_met_m3_p5); - xmm3 = simde_mm_max_epi16(bit_met_m5_p5, bit_met_m7_p5); - xmm4 = simde_mm_max_epi16(xmm0, xmm1); - xmm5 = simde_mm_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm_max_epi16(logmax_num_re0, xmm5); + xmm0 = max_epi16(bit_met_s[6],bit_met_s[14],bit_met_s[22],bit_met_s[30],bit_met_s[38],bit_met_s[46],bit_met_s[54],bit_met_s[62]); + xmm1 = max_epi16(bit_met_s[5],bit_met_s[13],bit_met_s[21],bit_met_s[29],bit_met_s[37],bit_met_s[45],bit_met_s[53],bit_met_s[61]); + xmm2 = max_epi16(bit_met_s[2],bit_met_s[10],bit_met_s[18],bit_met_s[26],bit_met_s[34],bit_met_s[42],bit_met_s[50],bit_met_s[58]); + xmm3 = max_epi16(bit_met_s[1],bit_met_s[9],bit_met_s[17],bit_met_s[25],bit_met_s[33],bit_met_s[41],bit_met_s[49],bit_met_s[57]); + logmax_num_re0 = simde_mm_max_epi16(simde_mm_max_epi16(xmm0, xmm1), simde_mm_max_epi16(xmm2, xmm3)); simde__m128i y2i = simde_mm_subs_epi16(logmax_num_re0, logmax_den_re0); @@ -3829,26 +1990,27 @@ void nr_ulsch_qam64_qam64(c16_t *stream0_in, for (int i = 0; i < len256; i += 2) { // Get rho - simde__m256i xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8; + simde__m256i xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8; simde_mm256_separate_real_imag_parts(&xmm2, &xmm3, rho01_256i[i], rho01_256i[i + 1]); simde__m256i rho_rpi = simde_mm256_adds_epi16(xmm2, xmm3); // rho = Re(rho) + Im(rho) simde__m256i rho_rmi = simde_mm256_subs_epi16(xmm2, xmm3); // rho* = Re(rho) - Im(rho) // Compute the different rhos - simde__m256i rho_rpi_1_1 = simde_mm256_mulhi_epi16(rho_rpi, ONE_OVER_SQRT_42); - simde__m256i rho_rmi_1_1 = simde_mm256_mulhi_epi16(rho_rmi, ONE_OVER_SQRT_42); - simde__m256i rho_rpi_3_3 = simde_mm256_mulhi_epi16(rho_rpi, THREE_OVER_SQRT_42); - simde__m256i rho_rmi_3_3 = simde_mm256_mulhi_epi16(rho_rmi, THREE_OVER_SQRT_42); - simde__m256i rho_rpi_5_5 = simde_mm256_mulhi_epi16(rho_rpi, FIVE_OVER_SQRT_42); - simde__m256i rho_rmi_5_5 = simde_mm256_mulhi_epi16(rho_rmi, FIVE_OVER_SQRT_42); - simde__m256i rho_rpi_7_7 = simde_mm256_mulhi_epi16(rho_rpi, SEVEN_OVER_SQRT_42); - simde__m256i rho_rmi_7_7 = simde_mm256_mulhi_epi16(rho_rmi, SEVEN_OVER_SQRT_42); + simde__m256i rho_rs[32] __attribute__((aligned(16))); + rho_rs[27] = simde_mm256_mulhi_epi16(rho_rpi, ONE_OVER_SQRT_42); + rho_rs[28] = simde_mm256_mulhi_epi16(rho_rmi, ONE_OVER_SQRT_42); + rho_rs[18] = simde_mm256_mulhi_epi16(rho_rpi, THREE_OVER_SQRT_42); + rho_rs[21] = simde_mm256_mulhi_epi16(rho_rmi, THREE_OVER_SQRT_42); + rho_rs[9] = simde_mm256_mulhi_epi16(rho_rpi, FIVE_OVER_SQRT_42); + rho_rs[14] = simde_mm256_mulhi_epi16(rho_rmi, FIVE_OVER_SQRT_42); + rho_rs[0] = simde_mm256_mulhi_epi16(rho_rpi, SEVEN_OVER_SQRT_42); + rho_rs[7] = simde_mm256_mulhi_epi16(rho_rmi, SEVEN_OVER_SQRT_42); - rho_rpi_5_5 = simde_mm256_slli_epi16(rho_rpi_5_5, 1); - rho_rmi_5_5 = simde_mm256_slli_epi16(rho_rmi_5_5, 1); - rho_rpi_7_7 = simde_mm256_slli_epi16(rho_rpi_7_7, 2); - rho_rmi_7_7 = simde_mm256_slli_epi16(rho_rmi_7_7, 2); + rho_rs[9] = simde_mm256_slli_epi16(rho_rs[9], 1); + rho_rs[14] = simde_mm256_slli_epi16(rho_rs[14], 1); + rho_rs[0] = simde_mm256_slli_epi16(rho_rs[0], 2); + rho_rs[7] = simde_mm256_slli_epi16(rho_rs[7], 2); xmm4 = simde_mm256_mulhi_epi16(xmm2, ONE_OVER_SQRT_42); xmm5 = simde_mm256_mulhi_epi16(xmm3, ONE_OVER_SQRT_42); @@ -3858,306 +2020,68 @@ void nr_ulsch_qam64_qam64(c16_t *stream0_in, xmm7 = simde_mm256_slli_epi16(xmm7, 1); xmm8 = simde_mm256_slli_epi16(xmm8, 2); - simde__m256i rho_rpi_1_3 = simde_mm256_adds_epi16(xmm4, xmm6); - simde__m256i rho_rmi_1_3 = simde_mm256_subs_epi16(xmm4, xmm6); - simde__m256i rho_rpi_1_5 = simde_mm256_adds_epi16(xmm4, xmm7); - simde__m256i rho_rmi_1_5 = simde_mm256_subs_epi16(xmm4, xmm7); - simde__m256i rho_rpi_1_7 = simde_mm256_adds_epi16(xmm4, xmm8); - simde__m256i rho_rmi_1_7 = simde_mm256_subs_epi16(xmm4, xmm8); + rho_rs[26] = simde_mm256_adds_epi16(xmm4, xmm6); + rho_rs[29] = simde_mm256_subs_epi16(xmm4, xmm6); + rho_rs[25] = simde_mm256_adds_epi16(xmm4, xmm7); + rho_rs[30] = simde_mm256_subs_epi16(xmm4, xmm7); + rho_rs[24] = simde_mm256_adds_epi16(xmm4, xmm8); + rho_rs[31] = simde_mm256_subs_epi16(xmm4, xmm8); xmm4 = simde_mm256_mulhi_epi16(xmm2, THREE_OVER_SQRT_42); - simde__m256i rho_rpi_3_1 = simde_mm256_adds_epi16(xmm4, xmm5); - simde__m256i rho_rmi_3_1 = simde_mm256_subs_epi16(xmm4, xmm5); - simde__m256i rho_rpi_3_5 = simde_mm256_adds_epi16(xmm4, xmm7); - simde__m256i rho_rmi_3_5 = simde_mm256_subs_epi16(xmm4, xmm7); - simde__m256i rho_rpi_3_7 = simde_mm256_adds_epi16(xmm4, xmm8); - simde__m256i rho_rmi_3_7 = simde_mm256_subs_epi16(xmm4, xmm8); + rho_rs[19] = simde_mm256_adds_epi16(xmm4, xmm5); + rho_rs[20] = simde_mm256_subs_epi16(xmm4, xmm5); + rho_rs[17] = simde_mm256_adds_epi16(xmm4, xmm7); + rho_rs[22] = simde_mm256_subs_epi16(xmm4, xmm7); + rho_rs[16] = simde_mm256_adds_epi16(xmm4, xmm8); + rho_rs[23] = simde_mm256_subs_epi16(xmm4, xmm8); xmm4 = simde_mm256_mulhi_epi16(xmm2, FIVE_OVER_SQRT_42); xmm4 = simde_mm256_slli_epi16(xmm4, 1); - simde__m256i rho_rpi_5_1 = simde_mm256_adds_epi16(xmm4, xmm5); - simde__m256i rho_rmi_5_1 = simde_mm256_subs_epi16(xmm4, xmm5); - simde__m256i rho_rpi_5_3 = simde_mm256_adds_epi16(xmm4, xmm6); - simde__m256i rho_rmi_5_3 = simde_mm256_subs_epi16(xmm4, xmm6); - simde__m256i rho_rpi_5_7 = simde_mm256_adds_epi16(xmm4, xmm8); - simde__m256i rho_rmi_5_7 = simde_mm256_subs_epi16(xmm4, xmm8); + rho_rs[11] = simde_mm256_adds_epi16(xmm4, xmm5); + rho_rs[12] = simde_mm256_subs_epi16(xmm4, xmm5); + rho_rs[10] = simde_mm256_adds_epi16(xmm4, xmm6); + rho_rs[13] = simde_mm256_subs_epi16(xmm4, xmm6); + rho_rs[8] = simde_mm256_adds_epi16(xmm4, xmm8); + rho_rs[15] = simde_mm256_subs_epi16(xmm4, xmm8); xmm4 = simde_mm256_mulhi_epi16(xmm2, SEVEN_OVER_SQRT_42); xmm4 = simde_mm256_slli_epi16(xmm4, 2); - simde__m256i rho_rpi_7_1 = simde_mm256_adds_epi16(xmm4, xmm5); - simde__m256i rho_rmi_7_1 = simde_mm256_subs_epi16(xmm4, xmm5); - simde__m256i rho_rpi_7_3 = simde_mm256_adds_epi16(xmm4, xmm6); - simde__m256i rho_rmi_7_3 = simde_mm256_subs_epi16(xmm4, xmm6); - simde__m256i rho_rpi_7_5 = simde_mm256_adds_epi16(xmm4, xmm7); - simde__m256i rho_rmi_7_5 = simde_mm256_subs_epi16(xmm4, xmm7); + rho_rs[3] = simde_mm256_adds_epi16(xmm4, xmm5); + rho_rs[4] = simde_mm256_subs_epi16(xmm4, xmm5); + rho_rs[2] = simde_mm256_adds_epi16(xmm4, xmm6); + rho_rs[5] = simde_mm256_subs_epi16(xmm4, xmm6); + rho_rs[1] = simde_mm256_adds_epi16(xmm4, xmm7); + rho_rs[6] = simde_mm256_subs_epi16(xmm4, xmm7); // Rearrange interfering MF output - simde__m256i y1r, y1i, xmm0; + simde__m256i y1r, y1i; simde_mm256_separate_real_imag_parts(&y1r, &y1i, stream1_256i_in[i], stream1_256i_in[i + 1]); // Psi_r calculation from rho_rpi or rho_rmi xmm0 = simde_mm256_broadcastw_epi16(simde_mm_set1_epi16(0)); // ZERO for abs_pi16 - xmm2 = simde_mm256_subs_epi16(rho_rpi_7_7, y1r); + xmm2 = simde_mm256_subs_epi16(rho_rs[0], y1r); - simde__m256i psi_r_p7_p7 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rpi_7_5, y1r); - simde__m256i psi_r_p7_p5 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rpi_7_3, y1r); - simde__m256i psi_r_p7_p3 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rpi_7_1, y1r); - simde__m256i psi_r_p7_p1 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rmi_7_1, y1r); - simde__m256i psi_r_p7_m1 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rmi_7_3, y1r); - simde__m256i psi_r_p7_m3 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rmi_7_5, y1r); - simde__m256i psi_r_p7_m5 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rmi_7_7, y1r); - simde__m256i psi_r_p7_m7 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rpi_5_7, y1r); - simde__m256i psi_r_p5_p7 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rpi_5_5, y1r); - simde__m256i psi_r_p5_p5 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rpi_5_3, y1r); - simde__m256i psi_r_p5_p3 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rpi_5_1, y1r); - simde__m256i psi_r_p5_p1 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rmi_5_1, y1r); - simde__m256i psi_r_p5_m1 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rmi_5_3, y1r); - simde__m256i psi_r_p5_m3 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rmi_5_5, y1r); - simde__m256i psi_r_p5_m5 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rmi_5_7, y1r); - simde__m256i psi_r_p5_m7 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rpi_3_7, y1r); - simde__m256i psi_r_p3_p7 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rpi_3_5, y1r); - simde__m256i psi_r_p3_p5 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rpi_3_3, y1r); - simde__m256i psi_r_p3_p3 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rpi_3_1, y1r); - simde__m256i psi_r_p3_p1 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rmi_3_1, y1r); - simde__m256i psi_r_p3_m1 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rmi_3_3, y1r); - simde__m256i psi_r_p3_m3 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rmi_3_5, y1r); - simde__m256i psi_r_p3_m5 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rmi_3_7, y1r); - simde__m256i psi_r_p3_m7 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rpi_1_7, y1r); - simde__m256i psi_r_p1_p7 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rpi_1_5, y1r); - simde__m256i psi_r_p1_p5 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rpi_1_3, y1r); - simde__m256i psi_r_p1_p3 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rpi_1_1, y1r); - simde__m256i psi_r_p1_p1 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rmi_1_1, y1r); - simde__m256i psi_r_p1_m1 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rmi_1_3, y1r); - simde__m256i psi_r_p1_m3 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rmi_1_5, y1r); - simde__m256i psi_r_p1_m5 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rmi_1_7, y1r); - simde__m256i psi_r_p1_m7 = simde_mm256_abs_epi16(xmm2); + simde__m256i psi_r_s[64] __attribute__((aligned(16))); + for(int j=0; j<32; j++) // psi_r_s[0~31], rho_rs[0~31] + psi_r_s[j] = simde_mm256_abs_epi16(simde_mm256_subs_epi16(rho_rs[j], y1r)); + for(int j=32; j<64; j++) // psi_r_s[32~64], rho_rs[31~0] + psi_r_s[j] = simde_mm256_abs_epi16(simde_mm256_adds_epi16(rho_rs[63 - j], y1r)); - xmm2 = simde_mm256_adds_epi16(rho_rmi_1_7, y1r); - simde__m256i psi_r_m1_p7 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rmi_1_5, y1r); - simde__m256i psi_r_m1_p5 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rmi_1_3, y1r); - simde__m256i psi_r_m1_p3 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rmi_1_1, y1r); - simde__m256i psi_r_m1_p1 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rpi_1_1, y1r); - simde__m256i psi_r_m1_m1 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rpi_1_3, y1r); - simde__m256i psi_r_m1_m3 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rpi_1_5, y1r); - simde__m256i psi_r_m1_m5 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rpi_1_7, y1r); - simde__m256i psi_r_m1_m7 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rmi_3_7, y1r); - simde__m256i psi_r_m3_p7 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rmi_3_5, y1r); - simde__m256i psi_r_m3_p5 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rmi_3_3, y1r); - simde__m256i psi_r_m3_p3 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rmi_3_1, y1r); - simde__m256i psi_r_m3_p1 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rpi_3_1, y1r); - simde__m256i psi_r_m3_m1 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rpi_3_3, y1r); - simde__m256i psi_r_m3_m3 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rpi_3_5, y1r); - simde__m256i psi_r_m3_m5 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rpi_3_7, y1r); - simde__m256i psi_r_m3_m7 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rmi_5_7, y1r); - simde__m256i psi_r_m5_p7 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rmi_5_5, y1r); - simde__m256i psi_r_m5_p5 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rmi_5_3, y1r); - simde__m256i psi_r_m5_p3 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rmi_5_1, y1r); - simde__m256i psi_r_m5_p1 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rpi_5_1, y1r); - simde__m256i psi_r_m5_m1 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rpi_5_3, y1r); - simde__m256i psi_r_m5_m3 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rpi_5_5, y1r); - simde__m256i psi_r_m5_m5 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rpi_5_7, y1r); - simde__m256i psi_r_m5_m7 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rmi_7_7, y1r); - simde__m256i psi_r_m7_p7 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rmi_7_5, y1r); - simde__m256i psi_r_m7_p5 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rmi_7_3, y1r); - simde__m256i psi_r_m7_p3 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rmi_7_1, y1r); - simde__m256i psi_r_m7_p1 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rpi_7_1, y1r); - simde__m256i psi_r_m7_m1 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rpi_7_3, y1r); - simde__m256i psi_r_m7_m3 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rpi_7_5, y1r); - simde__m256i psi_r_m7_m5 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rpi_7_7, y1r); - simde__m256i psi_r_m7_m7 = simde_mm256_abs_epi16(xmm2); - - // Simde__M256i Psi_i calculation from rho_rpi or rho_rmi - xmm2 = simde_mm256_subs_epi16(rho_rmi_7_7, y1i); - simde__m256i psi_i_p7_p7 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rmi_5_7, y1i); - simde__m256i psi_i_p7_p5 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rmi_3_7, y1i); - simde__m256i psi_i_p7_p3 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rmi_1_7, y1i); - simde__m256i psi_i_p7_p1 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rpi_1_7, y1i); - simde__m256i psi_i_p7_m1 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rpi_3_7, y1i); - simde__m256i psi_i_p7_m3 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rpi_5_7, y1i); - simde__m256i psi_i_p7_m5 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rpi_7_7, y1i); - simde__m256i psi_i_p7_m7 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rmi_7_5, y1i); - simde__m256i psi_i_p5_p7 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rmi_5_5, y1i); - simde__m256i psi_i_p5_p5 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rmi_3_5, y1i); - simde__m256i psi_i_p5_p3 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rmi_1_5, y1i); - simde__m256i psi_i_p5_p1 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rpi_1_5, y1i); - simde__m256i psi_i_p5_m1 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rpi_3_5, y1i); - simde__m256i psi_i_p5_m3 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rpi_5_5, y1i); - simde__m256i psi_i_p5_m5 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rpi_7_5, y1i); - simde__m256i psi_i_p5_m7 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rmi_7_3, y1i); - simde__m256i psi_i_p3_p7 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rmi_5_3, y1i); - simde__m256i psi_i_p3_p5 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rmi_3_3, y1i); - simde__m256i psi_i_p3_p3 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rmi_1_3, y1i); - simde__m256i psi_i_p3_p1 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rpi_1_3, y1i); - simde__m256i psi_i_p3_m1 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rpi_3_3, y1i); - simde__m256i psi_i_p3_m3 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rpi_5_3, y1i); - simde__m256i psi_i_p3_m5 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rpi_7_3, y1i); - simde__m256i psi_i_p3_m7 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rmi_7_1, y1i); - simde__m256i psi_i_p1_p7 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rmi_5_1, y1i); - simde__m256i psi_i_p1_p5 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rmi_3_1, y1i); - simde__m256i psi_i_p1_p3 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rmi_1_1, y1i); - simde__m256i psi_i_p1_p1 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rpi_1_1, y1i); - simde__m256i psi_i_p1_m1 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rpi_3_1, y1i); - simde__m256i psi_i_p1_m3 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rpi_5_1, y1i); - simde__m256i psi_i_p1_m5 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rpi_7_1, y1i); - simde__m256i psi_i_p1_m7 = simde_mm256_abs_epi16(xmm2); - - xmm2 = simde_mm256_subs_epi16(rho_rpi_7_1, y1i); - simde__m256i psi_i_m1_p7 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rpi_5_1, y1i); - simde__m256i psi_i_m1_p5 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rpi_3_1, y1i); - simde__m256i psi_i_m1_p3 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rpi_1_1, y1i); - simde__m256i psi_i_m1_p1 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rmi_1_1, y1i); - simde__m256i psi_i_m1_m1 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rmi_3_1, y1i); - simde__m256i psi_i_m1_m3 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rmi_5_1, y1i); - simde__m256i psi_i_m1_m5 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rmi_7_1, y1i); - simde__m256i psi_i_m1_m7 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rpi_7_3, y1i); - simde__m256i psi_i_m3_p7 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rpi_5_3, y1i); - simde__m256i psi_i_m3_p5 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rpi_3_3, y1i); - simde__m256i psi_i_m3_p3 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rpi_1_3, y1i); - simde__m256i psi_i_m3_p1 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rmi_1_3, y1i); - simde__m256i psi_i_m3_m1 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rmi_3_3, y1i); - simde__m256i psi_i_m3_m3 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rmi_5_3, y1i); - simde__m256i psi_i_m3_m5 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rmi_7_3, y1i); - simde__m256i psi_i_m3_m7 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rpi_7_5, y1i); - simde__m256i psi_i_m5_p7 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rpi_5_5, y1i); - simde__m256i psi_i_m5_p5 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rpi_3_5, y1i); - simde__m256i psi_i_m5_p3 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rpi_1_5, y1i); - simde__m256i psi_i_m5_p1 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rmi_1_5, y1i); - simde__m256i psi_i_m5_m1 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rmi_3_5, y1i); - simde__m256i psi_i_m5_m3 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rmi_5_5, y1i); - simde__m256i psi_i_m5_m5 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rmi_7_5, y1i); - simde__m256i psi_i_m5_m7 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rpi_7_7, y1i); - simde__m256i psi_i_m7_p7 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rpi_5_7, y1i); - simde__m256i psi_i_m7_p5 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rpi_3_7, y1i); - simde__m256i psi_i_m7_p3 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_subs_epi16(rho_rpi_1_7, y1i); - simde__m256i psi_i_m7_p1 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rmi_1_7, y1i); - simde__m256i psi_i_m7_m1 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rmi_3_7, y1i); - simde__m256i psi_i_m7_m3 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rmi_5_7, y1i); - simde__m256i psi_i_m7_m5 = simde_mm256_abs_epi16(xmm2); - xmm2 = simde_mm256_adds_epi16(rho_rmi_7_7, y1i); - simde__m256i psi_i_m7_m7 = simde_mm256_abs_epi16(xmm2); + // simde__m256i psi_i calculation from rho_rpi or rho_rmi + simde__m256i psi_i_s[64] __attribute__((aligned(16))); + const uint8_t rho_rs_index[32] = {7,15,23,31,24,16,8,0,6,14,22,30,25,17,9,1,5,13,21,29,26,18,10,2,4,12,20,28,27,19,11,3}; + for(int k=0; k<32; k+=8){ // psi_i_s[0~31] + for(int j=k; j>3], y0i_seven_over_sqrt_21); + y0_s[j+1] = simde_mm256_adds_epi16(y0r_over_s[j>>3], y0i_five_over_sqrt_21); + y0_s[j+2] = simde_mm256_adds_epi16(y0r_over_s[j>>3], y0i_three_over_sqrt_21); + y0_s[j+3] = simde_mm256_adds_epi16(y0r_over_s[j>>3], y0i_one_over_sqrt_21); + y0_s[j+4] = simde_mm256_subs_epi16(y0r_over_s[j>>3], y0i_one_over_sqrt_21); + y0_s[j+5] = simde_mm256_subs_epi16(y0r_over_s[j>>3], y0i_three_over_sqrt_21); + y0_s[j+6] = simde_mm256_subs_epi16(y0r_over_s[j>>3], y0i_five_over_sqrt_21); + y0_s[j+7] = simde_mm256_subs_epi16(y0r_over_s[j>>3], y0i_seven_over_sqrt_21); + } - simde__m256i y0_m_1_1 = simde_mm256_subs_epi16(y0r_one_over_sqrt_21, y0i_one_over_sqrt_21); - simde__m256i y0_m_1_3 = simde_mm256_subs_epi16(y0r_one_over_sqrt_21, y0i_three_over_sqrt_21); - simde__m256i y0_m_1_5 = simde_mm256_subs_epi16(y0r_one_over_sqrt_21, y0i_five_over_sqrt_21); - simde__m256i y0_m_1_7 = simde_mm256_subs_epi16(y0r_one_over_sqrt_21, y0i_seven_over_sqrt_21); - simde__m256i y0_m_3_1 = simde_mm256_subs_epi16(y0r_three_over_sqrt_21, y0i_one_over_sqrt_21); - simde__m256i y0_m_3_3 = simde_mm256_subs_epi16(y0r_three_over_sqrt_21, y0i_three_over_sqrt_21); - simde__m256i y0_m_3_5 = simde_mm256_subs_epi16(y0r_three_over_sqrt_21, y0i_five_over_sqrt_21); - simde__m256i y0_m_3_7 = simde_mm256_subs_epi16(y0r_three_over_sqrt_21, y0i_seven_over_sqrt_21); - simde__m256i y0_m_5_1 = simde_mm256_subs_epi16(y0r_five_over_sqrt_21, y0i_one_over_sqrt_21); - simde__m256i y0_m_5_3 = simde_mm256_subs_epi16(y0r_five_over_sqrt_21, y0i_three_over_sqrt_21); - simde__m256i y0_m_5_5 = simde_mm256_subs_epi16(y0r_five_over_sqrt_21, y0i_five_over_sqrt_21); - simde__m256i y0_m_5_7 = simde_mm256_subs_epi16(y0r_five_over_sqrt_21, y0i_seven_over_sqrt_21); - simde__m256i y0_m_7_1 = simde_mm256_subs_epi16(y0r_seven_over_sqrt_21, y0i_one_over_sqrt_21); - simde__m256i y0_m_7_3 = simde_mm256_subs_epi16(y0r_seven_over_sqrt_21, y0i_three_over_sqrt_21); - simde__m256i y0_m_7_5 = simde_mm256_subs_epi16(y0r_seven_over_sqrt_21, y0i_five_over_sqrt_21); - simde__m256i y0_m_7_7 = simde_mm256_subs_epi16(y0r_seven_over_sqrt_21, y0i_seven_over_sqrt_21); - - // Detection of interference term ch_mag_int_with_sigma2 = simde_mm256_srai_epi16(ch_mag_int, 1); // *2 two_ch_mag_int_with_sigma2 = ch_mag_int; // *4 three_ch_mag_int_with_sigma2 = simde_mm256_adds_epi16(ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2); // *6 - simde__m256i a_r_p7_p7 = interference_abs_64qam_epi16_256(psi_r_p7_p7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_p7_p5 = interference_abs_64qam_epi16_256(psi_r_p7_p5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_p7_p3 = interference_abs_64qam_epi16_256(psi_r_p7_p3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_p7_p1 = interference_abs_64qam_epi16_256(psi_r_p7_p1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_p7_m1 = interference_abs_64qam_epi16_256(psi_r_p7_m1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_p7_m3 = interference_abs_64qam_epi16_256(psi_r_p7_m3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_p7_m5 = interference_abs_64qam_epi16_256(psi_r_p7_m5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_p7_m7 = interference_abs_64qam_epi16_256(psi_r_p7_m7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_p5_p7 = interference_abs_64qam_epi16_256(psi_r_p5_p7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_p5_p5 = interference_abs_64qam_epi16_256(psi_r_p5_p5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_p5_p3 = interference_abs_64qam_epi16_256(psi_r_p5_p3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_p5_p1 = interference_abs_64qam_epi16_256(psi_r_p5_p1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_p5_m1 = interference_abs_64qam_epi16_256(psi_r_p5_m1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_p5_m3 = interference_abs_64qam_epi16_256(psi_r_p5_m3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_p5_m5 = interference_abs_64qam_epi16_256(psi_r_p5_m5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_p5_m7 = interference_abs_64qam_epi16_256(psi_r_p5_m7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_p3_p7 = interference_abs_64qam_epi16_256(psi_r_p3_p7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_p3_p5 = interference_abs_64qam_epi16_256(psi_r_p3_p5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_p3_p3 = interference_abs_64qam_epi16_256(psi_r_p3_p3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_p3_p1 = interference_abs_64qam_epi16_256(psi_r_p3_p1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_p3_m1 = interference_abs_64qam_epi16_256(psi_r_p3_m1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_p3_m3 = interference_abs_64qam_epi16_256(psi_r_p3_m3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_p3_m5 = interference_abs_64qam_epi16_256(psi_r_p3_m5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_p3_m7 = interference_abs_64qam_epi16_256(psi_r_p3_m7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_p1_p7 = interference_abs_64qam_epi16_256(psi_r_p1_p7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_p1_p5 = interference_abs_64qam_epi16_256(psi_r_p1_p5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_p1_p3 = interference_abs_64qam_epi16_256(psi_r_p1_p3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_p1_p1 = interference_abs_64qam_epi16_256(psi_r_p1_p1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_p1_m1 = interference_abs_64qam_epi16_256(psi_r_p1_m1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_p1_m3 = interference_abs_64qam_epi16_256(psi_r_p1_m3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_p1_m5 = interference_abs_64qam_epi16_256(psi_r_p1_m5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_p1_m7 = interference_abs_64qam_epi16_256(psi_r_p1_m7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_m1_p7 = interference_abs_64qam_epi16_256(psi_r_m1_p7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_m1_p5 = interference_abs_64qam_epi16_256(psi_r_m1_p5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_m1_p3 = interference_abs_64qam_epi16_256(psi_r_m1_p3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_m1_p1 = interference_abs_64qam_epi16_256(psi_r_m1_p1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_m1_m1 = interference_abs_64qam_epi16_256(psi_r_m1_m1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_m1_m3 = interference_abs_64qam_epi16_256(psi_r_m1_m3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_m1_m5 = interference_abs_64qam_epi16_256(psi_r_m1_m5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_m1_m7 = interference_abs_64qam_epi16_256(psi_r_m1_m7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_m3_p7 = interference_abs_64qam_epi16_256(psi_r_m3_p7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_m3_p5 = interference_abs_64qam_epi16_256(psi_r_m3_p5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_m3_p3 = interference_abs_64qam_epi16_256(psi_r_m3_p3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_m3_p1 = interference_abs_64qam_epi16_256(psi_r_m3_p1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_m3_m1 = interference_abs_64qam_epi16_256(psi_r_m3_m1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_m3_m3 = interference_abs_64qam_epi16_256(psi_r_m3_m3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_m3_m5 = interference_abs_64qam_epi16_256(psi_r_m3_m5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_m3_m7 = interference_abs_64qam_epi16_256(psi_r_m3_m7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_m5_p7 = interference_abs_64qam_epi16_256(psi_r_m5_p7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_m5_p5 = interference_abs_64qam_epi16_256(psi_r_m5_p5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_m5_p3 = interference_abs_64qam_epi16_256(psi_r_m5_p3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_m5_p1 = interference_abs_64qam_epi16_256(psi_r_m5_p1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_m5_m1 = interference_abs_64qam_epi16_256(psi_r_m5_m1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_m5_m3 = interference_abs_64qam_epi16_256(psi_r_m5_m3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_m5_m5 = interference_abs_64qam_epi16_256(psi_r_m5_m5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_m5_m7 = interference_abs_64qam_epi16_256(psi_r_m5_m7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_m7_p7 = interference_abs_64qam_epi16_256(psi_r_m7_p7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_m7_p5 = interference_abs_64qam_epi16_256(psi_r_m7_p5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_m7_p3 = interference_abs_64qam_epi16_256(psi_r_m7_p3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_m7_p1 = interference_abs_64qam_epi16_256(psi_r_m7_p1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_m7_m1 = interference_abs_64qam_epi16_256(psi_r_m7_m1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_m7_m3 = interference_abs_64qam_epi16_256(psi_r_m7_m3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_m7_m5 = interference_abs_64qam_epi16_256(psi_r_m7_m5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_r_m7_m7 = interference_abs_64qam_epi16_256(psi_r_m7_m7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); + simde__m256i a_r_s[64] __attribute__((aligned(16))); + simde__m256i a_i_s[64] __attribute__((aligned(16))); + simde__m256i psi_a_s[64] __attribute__((aligned(16))); + simde__m256i a_sq_s[64] __attribute__((aligned(16))); + for(int j=0; j<64; j++){ + // Detection of interference term + a_r_s[j] = interference_abs_64qam_epi16_256(psi_r_s[j], ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); + a_i_s[j] = interference_abs_64qam_epi16_256(psi_i_s[j], ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); + + // Calculation of a group of two terms in the bit metric involving product of psi and interference + psi_a_s[j] = prodsum_psi_a_epi16_256(psi_r_s[j], a_r_s[j], psi_i_s[j], a_i_s[j]); - simde__m256i a_i_p7_p7 = interference_abs_64qam_epi16_256(psi_i_p7_p7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_p7_p5 = interference_abs_64qam_epi16_256(psi_i_p7_p5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_p7_p3 = interference_abs_64qam_epi16_256(psi_i_p7_p3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_p7_p1 = interference_abs_64qam_epi16_256(psi_i_p7_p1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_p7_m1 = interference_abs_64qam_epi16_256(psi_i_p7_m1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_p7_m3 = interference_abs_64qam_epi16_256(psi_i_p7_m3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_p7_m5 = interference_abs_64qam_epi16_256(psi_i_p7_m5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_p7_m7 = interference_abs_64qam_epi16_256(psi_i_p7_m7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_p5_p7 = interference_abs_64qam_epi16_256(psi_i_p5_p7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_p5_p5 = interference_abs_64qam_epi16_256(psi_i_p5_p5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_p5_p3 = interference_abs_64qam_epi16_256(psi_i_p5_p3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_p5_p1 = interference_abs_64qam_epi16_256(psi_i_p5_p1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_p5_m1 = interference_abs_64qam_epi16_256(psi_i_p5_m1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_p5_m3 = interference_abs_64qam_epi16_256(psi_i_p5_m3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_p5_m5 = interference_abs_64qam_epi16_256(psi_i_p5_m5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_p5_m7 = interference_abs_64qam_epi16_256(psi_i_p5_m7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_p3_p7 = interference_abs_64qam_epi16_256(psi_i_p3_p7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_p3_p5 = interference_abs_64qam_epi16_256(psi_i_p3_p5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_p3_p3 = interference_abs_64qam_epi16_256(psi_i_p3_p3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_p3_p1 = interference_abs_64qam_epi16_256(psi_i_p3_p1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_p3_m1 = interference_abs_64qam_epi16_256(psi_i_p3_m1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_p3_m3 = interference_abs_64qam_epi16_256(psi_i_p3_m3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_p3_m5 = interference_abs_64qam_epi16_256(psi_i_p3_m5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_p3_m7 = interference_abs_64qam_epi16_256(psi_i_p3_m7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_p1_p7 = interference_abs_64qam_epi16_256(psi_i_p1_p7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_p1_p5 = interference_abs_64qam_epi16_256(psi_i_p1_p5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_p1_p3 = interference_abs_64qam_epi16_256(psi_i_p1_p3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_p1_p1 = interference_abs_64qam_epi16_256(psi_i_p1_p1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_p1_m1 = interference_abs_64qam_epi16_256(psi_i_p1_m1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_p1_m3 = interference_abs_64qam_epi16_256(psi_i_p1_m3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_p1_m5 = interference_abs_64qam_epi16_256(psi_i_p1_m5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_p1_m7 = interference_abs_64qam_epi16_256(psi_i_p1_m7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_m1_p7 = interference_abs_64qam_epi16_256(psi_i_m1_p7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_m1_p5 = interference_abs_64qam_epi16_256(psi_i_m1_p5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_m1_p3 = interference_abs_64qam_epi16_256(psi_i_m1_p3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_m1_p1 = interference_abs_64qam_epi16_256(psi_i_m1_p1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_m1_m1 = interference_abs_64qam_epi16_256(psi_i_m1_m1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_m1_m3 = interference_abs_64qam_epi16_256(psi_i_m1_m3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_m1_m5 = interference_abs_64qam_epi16_256(psi_i_m1_m5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_m1_m7 = interference_abs_64qam_epi16_256(psi_i_m1_m7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_m3_p7 = interference_abs_64qam_epi16_256(psi_i_m3_p7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_m3_p5 = interference_abs_64qam_epi16_256(psi_i_m3_p5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_m3_p3 = interference_abs_64qam_epi16_256(psi_i_m3_p3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_m3_p1 = interference_abs_64qam_epi16_256(psi_i_m3_p1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_m3_m1 = interference_abs_64qam_epi16_256(psi_i_m3_m1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_m3_m3 = interference_abs_64qam_epi16_256(psi_i_m3_m3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_m3_m5 = interference_abs_64qam_epi16_256(psi_i_m3_m5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_m3_m7 = interference_abs_64qam_epi16_256(psi_i_m3_m7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_m5_p7 = interference_abs_64qam_epi16_256(psi_i_m5_p7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_m5_p5 = interference_abs_64qam_epi16_256(psi_i_m5_p5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_m5_p3 = interference_abs_64qam_epi16_256(psi_i_m5_p3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_m5_p1 = interference_abs_64qam_epi16_256(psi_i_m5_p1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_m5_m1 = interference_abs_64qam_epi16_256(psi_i_m5_m1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_m5_m3 = interference_abs_64qam_epi16_256(psi_i_m5_m3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_m5_m5 = interference_abs_64qam_epi16_256(psi_i_m5_m5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_m5_m7 = interference_abs_64qam_epi16_256(psi_i_m5_m7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_m7_p7 = interference_abs_64qam_epi16_256(psi_i_m7_p7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_m7_p5 = interference_abs_64qam_epi16_256(psi_i_m7_p5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_m7_p3 = interference_abs_64qam_epi16_256(psi_i_m7_p3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_m7_p1 = interference_abs_64qam_epi16_256(psi_i_m7_p1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_m7_m1 = interference_abs_64qam_epi16_256(psi_i_m7_m1, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_m7_m3 = interference_abs_64qam_epi16_256(psi_i_m7_m3, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_m7_m5 = interference_abs_64qam_epi16_256(psi_i_m7_m5, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); - simde__m256i a_i_m7_m7 = interference_abs_64qam_epi16_256(psi_i_m7_m7, - ch_mag_int_with_sigma2, - two_ch_mag_int_with_sigma2, - three_ch_mag_int_with_sigma2, - ONE_OVER_SQRT_2_42, - THREE_OVER_SQRT_2_42, - FIVE_OVER_SQRT_2_42, - SEVEN_OVER_SQRT_2_42); + // Multiply by sqrt(2) + psi_a_s[j] = simde_mm256_slli_epi16(simde_mm256_mulhi_epi16(psi_a_s[j], ONE_OVER_SQRT_2), 2); - // Calculation of a group of two terms in the bit metric involving product of psi and interference - simde__m256i psi_a_p7_p7 = prodsum_psi_a_epi16_256(psi_r_p7_p7, a_r_p7_p7, psi_i_p7_p7, a_i_p7_p7); - simde__m256i psi_a_p7_p5 = prodsum_psi_a_epi16_256(psi_r_p7_p5, a_r_p7_p5, psi_i_p7_p5, a_i_p7_p5); - simde__m256i psi_a_p7_p3 = prodsum_psi_a_epi16_256(psi_r_p7_p3, a_r_p7_p3, psi_i_p7_p3, a_i_p7_p3); - simde__m256i psi_a_p7_p1 = prodsum_psi_a_epi16_256(psi_r_p7_p1, a_r_p7_p1, psi_i_p7_p1, a_i_p7_p1); - simde__m256i psi_a_p7_m1 = prodsum_psi_a_epi16_256(psi_r_p7_m1, a_r_p7_m1, psi_i_p7_m1, a_i_p7_m1); - simde__m256i psi_a_p7_m3 = prodsum_psi_a_epi16_256(psi_r_p7_m3, a_r_p7_m3, psi_i_p7_m3, a_i_p7_m3); - simde__m256i psi_a_p7_m5 = prodsum_psi_a_epi16_256(psi_r_p7_m5, a_r_p7_m5, psi_i_p7_m5, a_i_p7_m5); - simde__m256i psi_a_p7_m7 = prodsum_psi_a_epi16_256(psi_r_p7_m7, a_r_p7_m7, psi_i_p7_m7, a_i_p7_m7); - simde__m256i psi_a_p5_p7 = prodsum_psi_a_epi16_256(psi_r_p5_p7, a_r_p5_p7, psi_i_p5_p7, a_i_p5_p7); - simde__m256i psi_a_p5_p5 = prodsum_psi_a_epi16_256(psi_r_p5_p5, a_r_p5_p5, psi_i_p5_p5, a_i_p5_p5); - simde__m256i psi_a_p5_p3 = prodsum_psi_a_epi16_256(psi_r_p5_p3, a_r_p5_p3, psi_i_p5_p3, a_i_p5_p3); - simde__m256i psi_a_p5_p1 = prodsum_psi_a_epi16_256(psi_r_p5_p1, a_r_p5_p1, psi_i_p5_p1, a_i_p5_p1); - simde__m256i psi_a_p5_m1 = prodsum_psi_a_epi16_256(psi_r_p5_m1, a_r_p5_m1, psi_i_p5_m1, a_i_p5_m1); - simde__m256i psi_a_p5_m3 = prodsum_psi_a_epi16_256(psi_r_p5_m3, a_r_p5_m3, psi_i_p5_m3, a_i_p5_m3); - simde__m256i psi_a_p5_m5 = prodsum_psi_a_epi16_256(psi_r_p5_m5, a_r_p5_m5, psi_i_p5_m5, a_i_p5_m5); - simde__m256i psi_a_p5_m7 = prodsum_psi_a_epi16_256(psi_r_p5_m7, a_r_p5_m7, psi_i_p5_m7, a_i_p5_m7); - simde__m256i psi_a_p3_p7 = prodsum_psi_a_epi16_256(psi_r_p3_p7, a_r_p3_p7, psi_i_p3_p7, a_i_p3_p7); - simde__m256i psi_a_p3_p5 = prodsum_psi_a_epi16_256(psi_r_p3_p5, a_r_p3_p5, psi_i_p3_p5, a_i_p3_p5); - simde__m256i psi_a_p3_p3 = prodsum_psi_a_epi16_256(psi_r_p3_p3, a_r_p3_p3, psi_i_p3_p3, a_i_p3_p3); - simde__m256i psi_a_p3_p1 = prodsum_psi_a_epi16_256(psi_r_p3_p1, a_r_p3_p1, psi_i_p3_p1, a_i_p3_p1); - simde__m256i psi_a_p3_m1 = prodsum_psi_a_epi16_256(psi_r_p3_m1, a_r_p3_m1, psi_i_p3_m1, a_i_p3_m1); - simde__m256i psi_a_p3_m3 = prodsum_psi_a_epi16_256(psi_r_p3_m3, a_r_p3_m3, psi_i_p3_m3, a_i_p3_m3); - simde__m256i psi_a_p3_m5 = prodsum_psi_a_epi16_256(psi_r_p3_m5, a_r_p3_m5, psi_i_p3_m5, a_i_p3_m5); - simde__m256i psi_a_p3_m7 = prodsum_psi_a_epi16_256(psi_r_p3_m7, a_r_p3_m7, psi_i_p3_m7, a_i_p3_m7); - simde__m256i psi_a_p1_p7 = prodsum_psi_a_epi16_256(psi_r_p1_p7, a_r_p1_p7, psi_i_p1_p7, a_i_p1_p7); - simde__m256i psi_a_p1_p5 = prodsum_psi_a_epi16_256(psi_r_p1_p5, a_r_p1_p5, psi_i_p1_p5, a_i_p1_p5); - simde__m256i psi_a_p1_p3 = prodsum_psi_a_epi16_256(psi_r_p1_p3, a_r_p1_p3, psi_i_p1_p3, a_i_p1_p3); - simde__m256i psi_a_p1_p1 = prodsum_psi_a_epi16_256(psi_r_p1_p1, a_r_p1_p1, psi_i_p1_p1, a_i_p1_p1); - simde__m256i psi_a_p1_m1 = prodsum_psi_a_epi16_256(psi_r_p1_m1, a_r_p1_m1, psi_i_p1_m1, a_i_p1_m1); - simde__m256i psi_a_p1_m3 = prodsum_psi_a_epi16_256(psi_r_p1_m3, a_r_p1_m3, psi_i_p1_m3, a_i_p1_m3); - simde__m256i psi_a_p1_m5 = prodsum_psi_a_epi16_256(psi_r_p1_m5, a_r_p1_m5, psi_i_p1_m5, a_i_p1_m5); - simde__m256i psi_a_p1_m7 = prodsum_psi_a_epi16_256(psi_r_p1_m7, a_r_p1_m7, psi_i_p1_m7, a_i_p1_m7); - simde__m256i psi_a_m1_p7 = prodsum_psi_a_epi16_256(psi_r_m1_p7, a_r_m1_p7, psi_i_m1_p7, a_i_m1_p7); - simde__m256i psi_a_m1_p5 = prodsum_psi_a_epi16_256(psi_r_m1_p5, a_r_m1_p5, psi_i_m1_p5, a_i_m1_p5); - simde__m256i psi_a_m1_p3 = prodsum_psi_a_epi16_256(psi_r_m1_p3, a_r_m1_p3, psi_i_m1_p3, a_i_m1_p3); - simde__m256i psi_a_m1_p1 = prodsum_psi_a_epi16_256(psi_r_m1_p1, a_r_m1_p1, psi_i_m1_p1, a_i_m1_p1); - simde__m256i psi_a_m1_m1 = prodsum_psi_a_epi16_256(psi_r_m1_m1, a_r_m1_m1, psi_i_m1_m1, a_i_m1_m1); - simde__m256i psi_a_m1_m3 = prodsum_psi_a_epi16_256(psi_r_m1_m3, a_r_m1_m3, psi_i_m1_m3, a_i_m1_m3); - simde__m256i psi_a_m1_m5 = prodsum_psi_a_epi16_256(psi_r_m1_m5, a_r_m1_m5, psi_i_m1_m5, a_i_m1_m5); - simde__m256i psi_a_m1_m7 = prodsum_psi_a_epi16_256(psi_r_m1_m7, a_r_m1_m7, psi_i_m1_m7, a_i_m1_m7); - simde__m256i psi_a_m3_p7 = prodsum_psi_a_epi16_256(psi_r_m3_p7, a_r_m3_p7, psi_i_m3_p7, a_i_m3_p7); - simde__m256i psi_a_m3_p5 = prodsum_psi_a_epi16_256(psi_r_m3_p5, a_r_m3_p5, psi_i_m3_p5, a_i_m3_p5); - simde__m256i psi_a_m3_p3 = prodsum_psi_a_epi16_256(psi_r_m3_p3, a_r_m3_p3, psi_i_m3_p3, a_i_m3_p3); - simde__m256i psi_a_m3_p1 = prodsum_psi_a_epi16_256(psi_r_m3_p1, a_r_m3_p1, psi_i_m3_p1, a_i_m3_p1); - simde__m256i psi_a_m3_m1 = prodsum_psi_a_epi16_256(psi_r_m3_m1, a_r_m3_m1, psi_i_m3_m1, a_i_m3_m1); - simde__m256i psi_a_m3_m3 = prodsum_psi_a_epi16_256(psi_r_m3_m3, a_r_m3_m3, psi_i_m3_m3, a_i_m3_m3); - simde__m256i psi_a_m3_m5 = prodsum_psi_a_epi16_256(psi_r_m3_m5, a_r_m3_m5, psi_i_m3_m5, a_i_m3_m5); - simde__m256i psi_a_m3_m7 = prodsum_psi_a_epi16_256(psi_r_m3_m7, a_r_m3_m7, psi_i_m3_m7, a_i_m3_m7); - simde__m256i psi_a_m5_p7 = prodsum_psi_a_epi16_256(psi_r_m5_p7, a_r_m5_p7, psi_i_m5_p7, a_i_m5_p7); - simde__m256i psi_a_m5_p5 = prodsum_psi_a_epi16_256(psi_r_m5_p5, a_r_m5_p5, psi_i_m5_p5, a_i_m5_p5); - simde__m256i psi_a_m5_p3 = prodsum_psi_a_epi16_256(psi_r_m5_p3, a_r_m5_p3, psi_i_m5_p3, a_i_m5_p3); - simde__m256i psi_a_m5_p1 = prodsum_psi_a_epi16_256(psi_r_m5_p1, a_r_m5_p1, psi_i_m5_p1, a_i_m5_p1); - simde__m256i psi_a_m5_m1 = prodsum_psi_a_epi16_256(psi_r_m5_m1, a_r_m5_m1, psi_i_m5_m1, a_i_m5_m1); - simde__m256i psi_a_m5_m3 = prodsum_psi_a_epi16_256(psi_r_m5_m3, a_r_m5_m3, psi_i_m5_m3, a_i_m5_m3); - simde__m256i psi_a_m5_m5 = prodsum_psi_a_epi16_256(psi_r_m5_m5, a_r_m5_m5, psi_i_m5_m5, a_i_m5_m5); - simde__m256i psi_a_m5_m7 = prodsum_psi_a_epi16_256(psi_r_m5_m7, a_r_m5_m7, psi_i_m5_m7, a_i_m5_m7); - simde__m256i psi_a_m7_p7 = prodsum_psi_a_epi16_256(psi_r_m7_p7, a_r_m7_p7, psi_i_m7_p7, a_i_m7_p7); - simde__m256i psi_a_m7_p5 = prodsum_psi_a_epi16_256(psi_r_m7_p5, a_r_m7_p5, psi_i_m7_p5, a_i_m7_p5); - simde__m256i psi_a_m7_p3 = prodsum_psi_a_epi16_256(psi_r_m7_p3, a_r_m7_p3, psi_i_m7_p3, a_i_m7_p3); - simde__m256i psi_a_m7_p1 = prodsum_psi_a_epi16_256(psi_r_m7_p1, a_r_m7_p1, psi_i_m7_p1, a_i_m7_p1); - simde__m256i psi_a_m7_m1 = prodsum_psi_a_epi16_256(psi_r_m7_m1, a_r_m7_m1, psi_i_m7_m1, a_i_m7_m1); - simde__m256i psi_a_m7_m3 = prodsum_psi_a_epi16_256(psi_r_m7_m3, a_r_m7_m3, psi_i_m7_m3, a_i_m7_m3); - simde__m256i psi_a_m7_m5 = prodsum_psi_a_epi16_256(psi_r_m7_m5, a_r_m7_m5, psi_i_m7_m5, a_i_m7_m5); - simde__m256i psi_a_m7_m7 = prodsum_psi_a_epi16_256(psi_r_m7_m7, a_r_m7_m7, psi_i_m7_m7, a_i_m7_m7); - - // Multiply by sqrt(2) - psi_a_p7_p7 = simde_mm256_mulhi_epi16(psi_a_p7_p7, ONE_OVER_SQRT_2); - psi_a_p7_p7 = simde_mm256_slli_epi16(psi_a_p7_p7, 2); - psi_a_p7_p5 = simde_mm256_mulhi_epi16(psi_a_p7_p5, ONE_OVER_SQRT_2); - psi_a_p7_p5 = simde_mm256_slli_epi16(psi_a_p7_p5, 2); - psi_a_p7_p3 = simde_mm256_mulhi_epi16(psi_a_p7_p3, ONE_OVER_SQRT_2); - psi_a_p7_p3 = simde_mm256_slli_epi16(psi_a_p7_p3, 2); - psi_a_p7_p1 = simde_mm256_mulhi_epi16(psi_a_p7_p1, ONE_OVER_SQRT_2); - psi_a_p7_p1 = simde_mm256_slli_epi16(psi_a_p7_p1, 2); - psi_a_p7_m1 = simde_mm256_mulhi_epi16(psi_a_p7_m1, ONE_OVER_SQRT_2); - psi_a_p7_m1 = simde_mm256_slli_epi16(psi_a_p7_m1, 2); - psi_a_p7_m3 = simde_mm256_mulhi_epi16(psi_a_p7_m3, ONE_OVER_SQRT_2); - psi_a_p7_m3 = simde_mm256_slli_epi16(psi_a_p7_m3, 2); - psi_a_p7_m5 = simde_mm256_mulhi_epi16(psi_a_p7_m5, ONE_OVER_SQRT_2); - psi_a_p7_m5 = simde_mm256_slli_epi16(psi_a_p7_m5, 2); - psi_a_p7_m7 = simde_mm256_mulhi_epi16(psi_a_p7_m7, ONE_OVER_SQRT_2); - psi_a_p7_m7 = simde_mm256_slli_epi16(psi_a_p7_m7, 2); - psi_a_p5_p7 = simde_mm256_mulhi_epi16(psi_a_p5_p7, ONE_OVER_SQRT_2); - psi_a_p5_p7 = simde_mm256_slli_epi16(psi_a_p5_p7, 2); - psi_a_p5_p5 = simde_mm256_mulhi_epi16(psi_a_p5_p5, ONE_OVER_SQRT_2); - psi_a_p5_p5 = simde_mm256_slli_epi16(psi_a_p5_p5, 2); - psi_a_p5_p3 = simde_mm256_mulhi_epi16(psi_a_p5_p3, ONE_OVER_SQRT_2); - psi_a_p5_p3 = simde_mm256_slli_epi16(psi_a_p5_p3, 2); - psi_a_p5_p1 = simde_mm256_mulhi_epi16(psi_a_p5_p1, ONE_OVER_SQRT_2); - psi_a_p5_p1 = simde_mm256_slli_epi16(psi_a_p5_p1, 2); - psi_a_p5_m1 = simde_mm256_mulhi_epi16(psi_a_p5_m1, ONE_OVER_SQRT_2); - psi_a_p5_m1 = simde_mm256_slli_epi16(psi_a_p5_m1, 2); - psi_a_p5_m3 = simde_mm256_mulhi_epi16(psi_a_p5_m3, ONE_OVER_SQRT_2); - psi_a_p5_m3 = simde_mm256_slli_epi16(psi_a_p5_m3, 2); - psi_a_p5_m5 = simde_mm256_mulhi_epi16(psi_a_p5_m5, ONE_OVER_SQRT_2); - psi_a_p5_m5 = simde_mm256_slli_epi16(psi_a_p5_m5, 2); - psi_a_p5_m7 = simde_mm256_mulhi_epi16(psi_a_p5_m7, ONE_OVER_SQRT_2); - psi_a_p5_m7 = simde_mm256_slli_epi16(psi_a_p5_m7, 2); - psi_a_p3_p7 = simde_mm256_mulhi_epi16(psi_a_p3_p7, ONE_OVER_SQRT_2); - psi_a_p3_p7 = simde_mm256_slli_epi16(psi_a_p3_p7, 2); - psi_a_p3_p5 = simde_mm256_mulhi_epi16(psi_a_p3_p5, ONE_OVER_SQRT_2); - psi_a_p3_p5 = simde_mm256_slli_epi16(psi_a_p3_p5, 2); - psi_a_p3_p3 = simde_mm256_mulhi_epi16(psi_a_p3_p3, ONE_OVER_SQRT_2); - psi_a_p3_p3 = simde_mm256_slli_epi16(psi_a_p3_p3, 2); - psi_a_p3_p1 = simde_mm256_mulhi_epi16(psi_a_p3_p1, ONE_OVER_SQRT_2); - psi_a_p3_p1 = simde_mm256_slli_epi16(psi_a_p3_p1, 2); - psi_a_p3_m1 = simde_mm256_mulhi_epi16(psi_a_p3_m1, ONE_OVER_SQRT_2); - psi_a_p3_m1 = simde_mm256_slli_epi16(psi_a_p3_m1, 2); - psi_a_p3_m3 = simde_mm256_mulhi_epi16(psi_a_p3_m3, ONE_OVER_SQRT_2); - psi_a_p3_m3 = simde_mm256_slli_epi16(psi_a_p3_m3, 2); - psi_a_p3_m5 = simde_mm256_mulhi_epi16(psi_a_p3_m5, ONE_OVER_SQRT_2); - psi_a_p3_m5 = simde_mm256_slli_epi16(psi_a_p3_m5, 2); - psi_a_p3_m7 = simde_mm256_mulhi_epi16(psi_a_p3_m7, ONE_OVER_SQRT_2); - psi_a_p3_m7 = simde_mm256_slli_epi16(psi_a_p3_m7, 2); - psi_a_p1_p7 = simde_mm256_mulhi_epi16(psi_a_p1_p7, ONE_OVER_SQRT_2); - psi_a_p1_p7 = simde_mm256_slli_epi16(psi_a_p1_p7, 2); - psi_a_p1_p5 = simde_mm256_mulhi_epi16(psi_a_p1_p5, ONE_OVER_SQRT_2); - psi_a_p1_p5 = simde_mm256_slli_epi16(psi_a_p1_p5, 2); - psi_a_p1_p3 = simde_mm256_mulhi_epi16(psi_a_p1_p3, ONE_OVER_SQRT_2); - psi_a_p1_p3 = simde_mm256_slli_epi16(psi_a_p1_p3, 2); - psi_a_p1_p1 = simde_mm256_mulhi_epi16(psi_a_p1_p1, ONE_OVER_SQRT_2); - psi_a_p1_p1 = simde_mm256_slli_epi16(psi_a_p1_p1, 2); - psi_a_p1_m1 = simde_mm256_mulhi_epi16(psi_a_p1_m1, ONE_OVER_SQRT_2); - psi_a_p1_m1 = simde_mm256_slli_epi16(psi_a_p1_m1, 2); - psi_a_p1_m3 = simde_mm256_mulhi_epi16(psi_a_p1_m3, ONE_OVER_SQRT_2); - psi_a_p1_m3 = simde_mm256_slli_epi16(psi_a_p1_m3, 2); - psi_a_p1_m5 = simde_mm256_mulhi_epi16(psi_a_p1_m5, ONE_OVER_SQRT_2); - psi_a_p1_m5 = simde_mm256_slli_epi16(psi_a_p1_m5, 2); - psi_a_p1_m7 = simde_mm256_mulhi_epi16(psi_a_p1_m7, ONE_OVER_SQRT_2); - psi_a_p1_m7 = simde_mm256_slli_epi16(psi_a_p1_m7, 2); - psi_a_m1_p7 = simde_mm256_mulhi_epi16(psi_a_m1_p7, ONE_OVER_SQRT_2); - psi_a_m1_p7 = simde_mm256_slli_epi16(psi_a_m1_p7, 2); - psi_a_m1_p5 = simde_mm256_mulhi_epi16(psi_a_m1_p5, ONE_OVER_SQRT_2); - psi_a_m1_p5 = simde_mm256_slli_epi16(psi_a_m1_p5, 2); - psi_a_m1_p3 = simde_mm256_mulhi_epi16(psi_a_m1_p3, ONE_OVER_SQRT_2); - psi_a_m1_p3 = simde_mm256_slli_epi16(psi_a_m1_p3, 2); - psi_a_m1_p1 = simde_mm256_mulhi_epi16(psi_a_m1_p1, ONE_OVER_SQRT_2); - psi_a_m1_p1 = simde_mm256_slli_epi16(psi_a_m1_p1, 2); - psi_a_m1_m1 = simde_mm256_mulhi_epi16(psi_a_m1_m1, ONE_OVER_SQRT_2); - psi_a_m1_m1 = simde_mm256_slli_epi16(psi_a_m1_m1, 2); - psi_a_m1_m3 = simde_mm256_mulhi_epi16(psi_a_m1_m3, ONE_OVER_SQRT_2); - psi_a_m1_m3 = simde_mm256_slli_epi16(psi_a_m1_m3, 2); - psi_a_m1_m5 = simde_mm256_mulhi_epi16(psi_a_m1_m5, ONE_OVER_SQRT_2); - psi_a_m1_m5 = simde_mm256_slli_epi16(psi_a_m1_m5, 2); - psi_a_m1_m7 = simde_mm256_mulhi_epi16(psi_a_m1_m7, ONE_OVER_SQRT_2); - psi_a_m1_m7 = simde_mm256_slli_epi16(psi_a_m1_m7, 2); - psi_a_m3_p7 = simde_mm256_mulhi_epi16(psi_a_m3_p7, ONE_OVER_SQRT_2); - psi_a_m3_p7 = simde_mm256_slli_epi16(psi_a_m3_p7, 2); - psi_a_m3_p5 = simde_mm256_mulhi_epi16(psi_a_m3_p5, ONE_OVER_SQRT_2); - psi_a_m3_p5 = simde_mm256_slli_epi16(psi_a_m3_p5, 2); - psi_a_m3_p3 = simde_mm256_mulhi_epi16(psi_a_m3_p3, ONE_OVER_SQRT_2); - psi_a_m3_p3 = simde_mm256_slli_epi16(psi_a_m3_p3, 2); - psi_a_m3_p1 = simde_mm256_mulhi_epi16(psi_a_m3_p1, ONE_OVER_SQRT_2); - psi_a_m3_p1 = simde_mm256_slli_epi16(psi_a_m3_p1, 2); - psi_a_m3_m1 = simde_mm256_mulhi_epi16(psi_a_m3_m1, ONE_OVER_SQRT_2); - psi_a_m3_m1 = simde_mm256_slli_epi16(psi_a_m3_m1, 2); - psi_a_m3_m3 = simde_mm256_mulhi_epi16(psi_a_m3_m3, ONE_OVER_SQRT_2); - psi_a_m3_m3 = simde_mm256_slli_epi16(psi_a_m3_m3, 2); - psi_a_m3_m5 = simde_mm256_mulhi_epi16(psi_a_m3_m5, ONE_OVER_SQRT_2); - psi_a_m3_m5 = simde_mm256_slli_epi16(psi_a_m3_m5, 2); - psi_a_m3_m7 = simde_mm256_mulhi_epi16(psi_a_m3_m7, ONE_OVER_SQRT_2); - psi_a_m3_m7 = simde_mm256_slli_epi16(psi_a_m3_m7, 2); - psi_a_m5_p7 = simde_mm256_mulhi_epi16(psi_a_m5_p7, ONE_OVER_SQRT_2); - psi_a_m5_p7 = simde_mm256_slli_epi16(psi_a_m5_p7, 2); - psi_a_m5_p5 = simde_mm256_mulhi_epi16(psi_a_m5_p5, ONE_OVER_SQRT_2); - psi_a_m5_p5 = simde_mm256_slli_epi16(psi_a_m5_p5, 2); - psi_a_m5_p3 = simde_mm256_mulhi_epi16(psi_a_m5_p3, ONE_OVER_SQRT_2); - psi_a_m5_p3 = simde_mm256_slli_epi16(psi_a_m5_p3, 2); - psi_a_m5_p1 = simde_mm256_mulhi_epi16(psi_a_m5_p1, ONE_OVER_SQRT_2); - psi_a_m5_p1 = simde_mm256_slli_epi16(psi_a_m5_p1, 2); - psi_a_m5_m1 = simde_mm256_mulhi_epi16(psi_a_m5_m1, ONE_OVER_SQRT_2); - psi_a_m5_m1 = simde_mm256_slli_epi16(psi_a_m5_m1, 2); - psi_a_m5_m3 = simde_mm256_mulhi_epi16(psi_a_m5_m3, ONE_OVER_SQRT_2); - psi_a_m5_m3 = simde_mm256_slli_epi16(psi_a_m5_m3, 2); - psi_a_m5_m5 = simde_mm256_mulhi_epi16(psi_a_m5_m5, ONE_OVER_SQRT_2); - psi_a_m5_m5 = simde_mm256_slli_epi16(psi_a_m5_m5, 2); - psi_a_m5_m7 = simde_mm256_mulhi_epi16(psi_a_m5_m7, ONE_OVER_SQRT_2); - psi_a_m5_m7 = simde_mm256_slli_epi16(psi_a_m5_m7, 2); - psi_a_m7_p7 = simde_mm256_mulhi_epi16(psi_a_m7_p7, ONE_OVER_SQRT_2); - psi_a_m7_p7 = simde_mm256_slli_epi16(psi_a_m7_p7, 2); - psi_a_m7_p5 = simde_mm256_mulhi_epi16(psi_a_m7_p5, ONE_OVER_SQRT_2); - psi_a_m7_p5 = simde_mm256_slli_epi16(psi_a_m7_p5, 2); - psi_a_m7_p3 = simde_mm256_mulhi_epi16(psi_a_m7_p3, ONE_OVER_SQRT_2); - psi_a_m7_p3 = simde_mm256_slli_epi16(psi_a_m7_p3, 2); - psi_a_m7_p1 = simde_mm256_mulhi_epi16(psi_a_m7_p1, ONE_OVER_SQRT_2); - psi_a_m7_p1 = simde_mm256_slli_epi16(psi_a_m7_p1, 2); - psi_a_m7_m1 = simde_mm256_mulhi_epi16(psi_a_m7_m1, ONE_OVER_SQRT_2); - psi_a_m7_m1 = simde_mm256_slli_epi16(psi_a_m7_m1, 2); - psi_a_m7_m3 = simde_mm256_mulhi_epi16(psi_a_m7_m3, ONE_OVER_SQRT_2); - psi_a_m7_m3 = simde_mm256_slli_epi16(psi_a_m7_m3, 2); - psi_a_m7_m5 = simde_mm256_mulhi_epi16(psi_a_m7_m5, ONE_OVER_SQRT_2); - psi_a_m7_m5 = simde_mm256_slli_epi16(psi_a_m7_m5, 2); - psi_a_m7_m7 = simde_mm256_mulhi_epi16(psi_a_m7_m7, ONE_OVER_SQRT_2); - psi_a_m7_m7 = simde_mm256_slli_epi16(psi_a_m7_m7, 2); - - // Calculation of a group of two terms in the bit metric involving squares of interference - simde__m256i a_sq_p7_p7 = square_a_64qam_epi16_256(a_r_p7_p7, a_i_p7_p7, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_p7_p5 = square_a_64qam_epi16_256(a_r_p7_p5, a_i_p7_p5, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_p7_p3 = square_a_64qam_epi16_256(a_r_p7_p3, a_i_p7_p3, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_p7_p1 = square_a_64qam_epi16_256(a_r_p7_p1, a_i_p7_p1, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_p7_m1 = square_a_64qam_epi16_256(a_r_p7_m1, a_i_p7_m1, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_p7_m3 = square_a_64qam_epi16_256(a_r_p7_m3, a_i_p7_m3, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_p7_m5 = square_a_64qam_epi16_256(a_r_p7_m5, a_i_p7_m5, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_p7_m7 = square_a_64qam_epi16_256(a_r_p7_m7, a_i_p7_m7, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_p5_p7 = square_a_64qam_epi16_256(a_r_p5_p7, a_i_p5_p7, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_p5_p5 = square_a_64qam_epi16_256(a_r_p5_p5, a_i_p5_p5, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_p5_p3 = square_a_64qam_epi16_256(a_r_p5_p3, a_i_p5_p3, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_p5_p1 = square_a_64qam_epi16_256(a_r_p5_p1, a_i_p5_p1, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_p5_m1 = square_a_64qam_epi16_256(a_r_p5_m1, a_i_p5_m1, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_p5_m3 = square_a_64qam_epi16_256(a_r_p5_m3, a_i_p5_m3, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_p5_m5 = square_a_64qam_epi16_256(a_r_p5_m5, a_i_p5_m5, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_p5_m7 = square_a_64qam_epi16_256(a_r_p5_m7, a_i_p5_m7, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_p3_p7 = square_a_64qam_epi16_256(a_r_p3_p7, a_i_p3_p7, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_p3_p5 = square_a_64qam_epi16_256(a_r_p3_p5, a_i_p3_p5, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_p3_p3 = square_a_64qam_epi16_256(a_r_p3_p3, a_i_p3_p3, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_p3_p1 = square_a_64qam_epi16_256(a_r_p3_p1, a_i_p3_p1, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_p3_m1 = square_a_64qam_epi16_256(a_r_p3_m1, a_i_p3_m1, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_p3_m3 = square_a_64qam_epi16_256(a_r_p3_m3, a_i_p3_m3, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_p3_m5 = square_a_64qam_epi16_256(a_r_p3_m5, a_i_p3_m5, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_p3_m7 = square_a_64qam_epi16_256(a_r_p3_m7, a_i_p3_m7, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_p1_p7 = square_a_64qam_epi16_256(a_r_p1_p7, a_i_p1_p7, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_p1_p5 = square_a_64qam_epi16_256(a_r_p1_p5, a_i_p1_p5, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_p1_p3 = square_a_64qam_epi16_256(a_r_p1_p3, a_i_p1_p3, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_p1_p1 = square_a_64qam_epi16_256(a_r_p1_p1, a_i_p1_p1, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_p1_m1 = square_a_64qam_epi16_256(a_r_p1_m1, a_i_p1_m1, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_p1_m3 = square_a_64qam_epi16_256(a_r_p1_m3, a_i_p1_m3, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_p1_m5 = square_a_64qam_epi16_256(a_r_p1_m5, a_i_p1_m5, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_p1_m7 = square_a_64qam_epi16_256(a_r_p1_m7, a_i_p1_m7, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_m1_p7 = square_a_64qam_epi16_256(a_r_m1_p7, a_i_m1_p7, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_m1_p5 = square_a_64qam_epi16_256(a_r_m1_p5, a_i_m1_p5, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_m1_p3 = square_a_64qam_epi16_256(a_r_m1_p3, a_i_m1_p3, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_m1_p1 = square_a_64qam_epi16_256(a_r_m1_p1, a_i_m1_p1, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_m1_m1 = square_a_64qam_epi16_256(a_r_m1_m1, a_i_m1_m1, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_m1_m3 = square_a_64qam_epi16_256(a_r_m1_m3, a_i_m1_m3, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_m1_m5 = square_a_64qam_epi16_256(a_r_m1_m5, a_i_m1_m5, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_m1_m7 = square_a_64qam_epi16_256(a_r_m1_m7, a_i_m1_m7, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_m3_p7 = square_a_64qam_epi16_256(a_r_m3_p7, a_i_m3_p7, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_m3_p5 = square_a_64qam_epi16_256(a_r_m3_p5, a_i_m3_p5, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_m3_p3 = square_a_64qam_epi16_256(a_r_m3_p3, a_i_m3_p3, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_m3_p1 = square_a_64qam_epi16_256(a_r_m3_p1, a_i_m3_p1, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_m3_m1 = square_a_64qam_epi16_256(a_r_m3_m1, a_i_m3_m1, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_m3_m3 = square_a_64qam_epi16_256(a_r_m3_m3, a_i_m3_m3, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_m3_m5 = square_a_64qam_epi16_256(a_r_m3_m5, a_i_m3_m5, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_m3_m7 = square_a_64qam_epi16_256(a_r_m3_m7, a_i_m3_m7, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_m5_p7 = square_a_64qam_epi16_256(a_r_m5_p7, a_i_m5_p7, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_m5_p5 = square_a_64qam_epi16_256(a_r_m5_p5, a_i_m5_p5, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_m5_p3 = square_a_64qam_epi16_256(a_r_m5_p3, a_i_m5_p3, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_m5_p1 = square_a_64qam_epi16_256(a_r_m5_p1, a_i_m5_p1, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_m5_m1 = square_a_64qam_epi16_256(a_r_m5_m1, a_i_m5_m1, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_m5_m3 = square_a_64qam_epi16_256(a_r_m5_m3, a_i_m5_m3, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_m5_m5 = square_a_64qam_epi16_256(a_r_m5_m5, a_i_m5_m5, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_m5_m7 = square_a_64qam_epi16_256(a_r_m5_m7, a_i_m5_m7, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_m7_p7 = square_a_64qam_epi16_256(a_r_m7_p7, a_i_m7_p7, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_m7_p5 = square_a_64qam_epi16_256(a_r_m7_p5, a_i_m7_p5, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_m7_p3 = square_a_64qam_epi16_256(a_r_m7_p3, a_i_m7_p3, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_m7_p1 = square_a_64qam_epi16_256(a_r_m7_p1, a_i_m7_p1, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_m7_m1 = square_a_64qam_epi16_256(a_r_m7_m1, a_i_m7_m1, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_m7_m3 = square_a_64qam_epi16_256(a_r_m7_m3, a_i_m7_m3, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_m7_m5 = square_a_64qam_epi16_256(a_r_m7_m5, a_i_m7_m5, ch_mag_int, SQRT_42_OVER_FOUR); - simde__m256i a_sq_m7_m7 = square_a_64qam_epi16_256(a_r_m7_m7, a_i_m7_m7, ch_mag_int, SQRT_42_OVER_FOUR); + // Calculation of a group of two terms in the bit metric involving squares of interference + a_sq_s[j] = square_a_64qam_epi16_256(a_r_s[j], a_i_s[j], ch_mag_int, SQRT_42_OVER_FOUR); + } // Computing different multiples of ||h0||^2 // x=1, y=1 @@ -5544,603 +2177,293 @@ void nr_ulsch_qam64_qam64(c16_t *stream0_in, ch_mag_98_over_42_with_sigma2 = simde_mm256_slli_epi16(ch_mag_98_over_42_with_sigma2, 2); // Computing Metrics - xmm0 = simde_mm256_subs_epi16(psi_a_p7_p7, a_sq_p7_p7); - simde__m256i xmm1 = simde_mm256_adds_epi16(xmm0, y0_p_7_7); - simde__m256i bit_met_p7_p7 = simde_mm256_subs_epi16(xmm1, ch_mag_98_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_p7_p5, a_sq_p7_p5); - xmm1 = simde_mm256_adds_epi16(xmm0, y0_p_7_5); - simde__m256i bit_met_p7_p5 = simde_mm256_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_p7_p3, a_sq_p7_p3); - xmm1 = simde_mm256_adds_epi16(xmm0, y0_p_7_3); - simde__m256i bit_met_p7_p3 = simde_mm256_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_p7_p1, a_sq_p7_p1); - xmm1 = simde_mm256_adds_epi16(xmm0, y0_p_7_1); - simde__m256i bit_met_p7_p1 = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_p7_m1, a_sq_p7_m1); - xmm1 = simde_mm256_adds_epi16(xmm0, y0_m_7_1); - simde__m256i bit_met_p7_m1 = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_p7_m3, a_sq_p7_m3); - xmm1 = simde_mm256_adds_epi16(xmm0, y0_m_7_3); - simde__m256i bit_met_p7_m3 = simde_mm256_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_p7_m5, a_sq_p7_m5); - xmm1 = simde_mm256_adds_epi16(xmm0, y0_m_7_5); - simde__m256i bit_met_p7_m5 = simde_mm256_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_p7_m7, a_sq_p7_m7); - xmm1 = simde_mm256_adds_epi16(xmm0, y0_m_7_7); - simde__m256i bit_met_p7_m7 = simde_mm256_subs_epi16(xmm1, ch_mag_98_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_p5_p7, a_sq_p5_p7); - xmm1 = simde_mm256_adds_epi16(xmm0, y0_p_5_7); - simde__m256i bit_met_p5_p7 = simde_mm256_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_p5_p5, a_sq_p5_p5); - xmm1 = simde_mm256_adds_epi16(xmm0, y0_p_5_5); - simde__m256i bit_met_p5_p5 = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_p5_p3, a_sq_p5_p3); - xmm1 = simde_mm256_adds_epi16(xmm0, y0_p_5_3); - simde__m256i bit_met_p5_p3 = simde_mm256_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_p5_p1, a_sq_p5_p1); - xmm1 = simde_mm256_adds_epi16(xmm0, y0_p_5_1); - simde__m256i bit_met_p5_p1 = simde_mm256_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_p5_m1, a_sq_p5_m1); - xmm1 = simde_mm256_adds_epi16(xmm0, y0_m_5_1); - simde__m256i bit_met_p5_m1 = simde_mm256_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_p5_m3, a_sq_p5_m3); - xmm1 = simde_mm256_adds_epi16(xmm0, y0_m_5_3); - simde__m256i bit_met_p5_m3 = simde_mm256_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_p5_m5, a_sq_p5_m5); - xmm1 = simde_mm256_adds_epi16(xmm0, y0_m_5_5); - simde__m256i bit_met_p5_m5 = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_p5_m7, a_sq_p5_m7); - xmm1 = simde_mm256_adds_epi16(xmm0, y0_m_5_7); - simde__m256i bit_met_p5_m7 = simde_mm256_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_p3_p7, a_sq_p3_p7); - xmm1 = simde_mm256_adds_epi16(xmm0, y0_p_3_7); - simde__m256i bit_met_p3_p7 = simde_mm256_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_p3_p5, a_sq_p3_p5); - xmm1 = simde_mm256_adds_epi16(xmm0, y0_p_3_5); - simde__m256i bit_met_p3_p5 = simde_mm256_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_p3_p3, a_sq_p3_p3); - xmm1 = simde_mm256_adds_epi16(xmm0, y0_p_3_3); - simde__m256i bit_met_p3_p3 = simde_mm256_subs_epi16(xmm1, ch_mag_18_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_p3_p1, a_sq_p3_p1); - xmm1 = simde_mm256_adds_epi16(xmm0, y0_p_3_1); - simde__m256i bit_met_p3_p1 = simde_mm256_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_p3_m1, a_sq_p3_m1); - xmm1 = simde_mm256_adds_epi16(xmm0, y0_m_3_1); - simde__m256i bit_met_p3_m1 = simde_mm256_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_p3_m3, a_sq_p3_m3); - xmm1 = simde_mm256_adds_epi16(xmm0, y0_m_3_3); - simde__m256i bit_met_p3_m3 = simde_mm256_subs_epi16(xmm1, ch_mag_18_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_p3_m5, a_sq_p3_m5); - xmm1 = simde_mm256_adds_epi16(xmm0, y0_m_3_5); - simde__m256i bit_met_p3_m5 = simde_mm256_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_p3_m7, a_sq_p3_m7); - xmm1 = simde_mm256_adds_epi16(xmm0, y0_m_3_7); - simde__m256i bit_met_p3_m7 = simde_mm256_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_p1_p7, a_sq_p1_p7); - xmm1 = simde_mm256_adds_epi16(xmm0, y0_p_1_7); - simde__m256i bit_met_p1_p7 = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_p1_p5, a_sq_p1_p5); - xmm1 = simde_mm256_adds_epi16(xmm0, y0_p_1_5); - simde__m256i bit_met_p1_p5 = simde_mm256_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_p1_p3, a_sq_p1_p3); - xmm1 = simde_mm256_adds_epi16(xmm0, y0_p_1_3); - simde__m256i bit_met_p1_p3 = simde_mm256_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_p1_p1, a_sq_p1_p1); - xmm1 = simde_mm256_adds_epi16(xmm0, y0_p_1_1); - simde__m256i bit_met_p1_p1 = simde_mm256_subs_epi16(xmm1, ch_mag_2_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_p1_m1, a_sq_p1_m1); - xmm1 = simde_mm256_adds_epi16(xmm0, y0_m_1_1); - simde__m256i bit_met_p1_m1 = simde_mm256_subs_epi16(xmm1, ch_mag_2_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_p1_m3, a_sq_p1_m3); - xmm1 = simde_mm256_adds_epi16(xmm0, y0_m_1_3); - simde__m256i bit_met_p1_m3 = simde_mm256_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_p1_m5, a_sq_p1_m5); - xmm1 = simde_mm256_adds_epi16(xmm0, y0_m_1_5); - simde__m256i bit_met_p1_m5 = simde_mm256_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_p1_m7, a_sq_p1_m7); - xmm1 = simde_mm256_adds_epi16(xmm0, y0_m_1_7); - simde__m256i bit_met_p1_m7 = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + simde__m256i bit_met_s[64] __attribute__((aligned(16))); - xmm0 = simde_mm256_subs_epi16(psi_a_m1_p7, a_sq_m1_p7); - xmm1 = simde_mm256_subs_epi16(xmm0, y0_m_1_7); - simde__m256i bit_met_m1_p7 = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_m1_p5, a_sq_m1_p5); - xmm1 = simde_mm256_subs_epi16(xmm0, y0_m_1_5); - simde__m256i bit_met_m1_p5 = simde_mm256_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_m1_p3, a_sq_m1_p3); - xmm1 = simde_mm256_subs_epi16(xmm0, y0_m_1_3); - simde__m256i bit_met_m1_p3 = simde_mm256_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_m1_p1, a_sq_m1_p1); - xmm1 = simde_mm256_subs_epi16(xmm0, y0_m_1_1); - simde__m256i bit_met_m1_p1 = simde_mm256_subs_epi16(xmm1, ch_mag_2_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_m1_m1, a_sq_m1_m1); - xmm1 = simde_mm256_subs_epi16(xmm0, y0_p_1_1); - simde__m256i bit_met_m1_m1 = simde_mm256_subs_epi16(xmm1, ch_mag_2_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_m1_m3, a_sq_m1_m3); - xmm1 = simde_mm256_subs_epi16(xmm0, y0_p_1_3); - simde__m256i bit_met_m1_m3 = simde_mm256_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_m1_m5, a_sq_m1_m5); - xmm1 = simde_mm256_subs_epi16(xmm0, y0_p_1_5); - simde__m256i bit_met_m1_m5 = simde_mm256_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_m1_m7, a_sq_m1_m7); - xmm1 = simde_mm256_subs_epi16(xmm0, y0_p_1_7); - simde__m256i bit_met_m1_m7 = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_m3_p7, a_sq_m3_p7); - xmm1 = simde_mm256_subs_epi16(xmm0, y0_m_3_7); - simde__m256i bit_met_m3_p7 = simde_mm256_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_m3_p5, a_sq_m3_p5); - xmm1 = simde_mm256_subs_epi16(xmm0, y0_m_3_5); - simde__m256i bit_met_m3_p5 = simde_mm256_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_m3_p3, a_sq_m3_p3); - xmm1 = simde_mm256_subs_epi16(xmm0, y0_m_3_3); - simde__m256i bit_met_m3_p3 = simde_mm256_subs_epi16(xmm1, ch_mag_18_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_m3_p1, a_sq_m3_p1); - xmm1 = simde_mm256_subs_epi16(xmm0, y0_m_3_1); - simde__m256i bit_met_m3_p1 = simde_mm256_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_m3_m1, a_sq_m3_m1); - xmm1 = simde_mm256_subs_epi16(xmm0, y0_p_3_1); - simde__m256i bit_met_m3_m1 = simde_mm256_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_m3_m3, a_sq_m3_m3); - xmm1 = simde_mm256_subs_epi16(xmm0, y0_p_3_3); - simde__m256i bit_met_m3_m3 = simde_mm256_subs_epi16(xmm1, ch_mag_18_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_m3_m5, a_sq_m3_m5); - xmm1 = simde_mm256_subs_epi16(xmm0, y0_p_3_5); - simde__m256i bit_met_m3_m5 = simde_mm256_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_m3_m7, a_sq_m3_m7); - xmm1 = simde_mm256_subs_epi16(xmm0, y0_p_3_7); - simde__m256i bit_met_m3_m7 = simde_mm256_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_m5_p7, a_sq_m5_p7); - xmm1 = simde_mm256_subs_epi16(xmm0, y0_m_5_7); - simde__m256i bit_met_m5_p7 = simde_mm256_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_m5_p5, a_sq_m5_p5); - xmm1 = simde_mm256_subs_epi16(xmm0, y0_m_5_5); - simde__m256i bit_met_m5_p5 = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_m5_p3, a_sq_m5_p3); - xmm1 = simde_mm256_subs_epi16(xmm0, y0_m_5_3); - simde__m256i bit_met_m5_p3 = simde_mm256_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_m5_p1, a_sq_m5_p1); - xmm1 = simde_mm256_subs_epi16(xmm0, y0_m_5_1); - simde__m256i bit_met_m5_p1 = simde_mm256_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_m5_m1, a_sq_m5_m1); - xmm1 = simde_mm256_subs_epi16(xmm0, y0_p_5_1); - simde__m256i bit_met_m5_m1 = simde_mm256_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_m5_m3, a_sq_m5_m3); - xmm1 = simde_mm256_subs_epi16(xmm0, y0_p_5_3); - simde__m256i bit_met_m5_m3 = simde_mm256_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_m5_m5, a_sq_m5_m5); - xmm1 = simde_mm256_subs_epi16(xmm0, y0_p_5_5); - simde__m256i bit_met_m5_m5 = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_m5_m7, a_sq_m5_m7); - xmm1 = simde_mm256_subs_epi16(xmm0, y0_p_5_7); - simde__m256i bit_met_m5_m7 = simde_mm256_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_m7_p7, a_sq_m7_p7); - xmm1 = simde_mm256_subs_epi16(xmm0, y0_m_7_7); - simde__m256i bit_met_m7_p7 = simde_mm256_subs_epi16(xmm1, ch_mag_98_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_m7_p5, a_sq_m7_p5); - xmm1 = simde_mm256_subs_epi16(xmm0, y0_m_7_5); - simde__m256i bit_met_m7_p5 = simde_mm256_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_m7_p3, a_sq_m7_p3); - xmm1 = simde_mm256_subs_epi16(xmm0, y0_m_7_3); - simde__m256i bit_met_m7_p3 = simde_mm256_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_m7_p1, a_sq_m7_p1); - xmm1 = simde_mm256_subs_epi16(xmm0, y0_m_7_1); - simde__m256i bit_met_m7_p1 = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_m7_m1, a_sq_m7_m1); - xmm1 = simde_mm256_subs_epi16(xmm0, y0_p_7_1); - simde__m256i bit_met_m7_m1 = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_m7_m3, a_sq_m7_m3); - xmm1 = simde_mm256_subs_epi16(xmm0, y0_p_7_3); - simde__m256i bit_met_m7_m3 = simde_mm256_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_m7_m5, a_sq_m7_m5); - xmm1 = simde_mm256_subs_epi16(xmm0, y0_p_7_5); - simde__m256i bit_met_m7_m5 = simde_mm256_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); - xmm0 = simde_mm256_subs_epi16(psi_a_m7_m7, a_sq_m7_m7); - xmm1 = simde_mm256_subs_epi16(xmm0, y0_p_7_7); - simde__m256i bit_met_m7_m7 = simde_mm256_subs_epi16(xmm1, ch_mag_98_over_42_with_sigma2); + xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[0], a_sq_s[0]), y0_s[0]); + bit_met_s[0] = simde_mm256_subs_epi16(xmm1, ch_mag_98_over_42_with_sigma2); + xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[1], a_sq_s[1]), y0_s[1]); + bit_met_s[1] = simde_mm256_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); + + xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[2], a_sq_s[2]), y0_s[2]); + bit_met_s[2] = simde_mm256_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); + + xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[3], a_sq_s[3]), y0_s[3]); + bit_met_s[3] = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + + xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[4], a_sq_s[4]), y0_s[4]); + bit_met_s[4] = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + + xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[5], a_sq_s[5]), y0_s[5]); + bit_met_s[5] = simde_mm256_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); + + xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[6], a_sq_s[6]), y0_s[6]); + bit_met_s[6] = simde_mm256_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); + + xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[7], a_sq_s[7]), y0_s[7]); + bit_met_s[7] = simde_mm256_subs_epi16(xmm1, ch_mag_98_over_42_with_sigma2); + + xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[8], a_sq_s[8]), y0_s[8]); + bit_met_s[8] = simde_mm256_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); + + xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[9], a_sq_s[9]), y0_s[9]); + bit_met_s[9] = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + + xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[10], a_sq_s[10]), y0_s[10]); + bit_met_s[10] = simde_mm256_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); + + xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[11], a_sq_s[11]), y0_s[11]); + bit_met_s[11] = simde_mm256_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); + + xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[12], a_sq_s[12]), y0_s[12]); + bit_met_s[12] = simde_mm256_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); + + xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[13], a_sq_s[13]), y0_s[13]); + bit_met_s[13] = simde_mm256_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); + + xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[14], a_sq_s[14]), y0_s[14]); + bit_met_s[14] = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + + xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[15], a_sq_s[15]), y0_s[15]); + bit_met_s[15] = simde_mm256_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); + + xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[16], a_sq_s[16]), y0_s[16]); + bit_met_s[16] = simde_mm256_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); + + xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[17], a_sq_s[17]), y0_s[17]); + bit_met_s[17] = simde_mm256_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); + + xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[18], a_sq_s[18]), y0_s[18]); + bit_met_s[18] = simde_mm256_subs_epi16(xmm1, ch_mag_18_over_42_with_sigma2); + + xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[19], a_sq_s[19]), y0_s[19]); + bit_met_s[19] = simde_mm256_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); + + xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[20], a_sq_s[20]), y0_s[20]); + bit_met_s[20] = simde_mm256_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); + + xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[21], a_sq_s[21]), y0_s[21]); + bit_met_s[21] = simde_mm256_subs_epi16(xmm1, ch_mag_18_over_42_with_sigma2); + + xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[22], a_sq_s[22]), y0_s[22]); + bit_met_s[22] = simde_mm256_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); + + xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[23], a_sq_s[23]), y0_s[23]); + bit_met_s[23] = simde_mm256_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); + + xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[24], a_sq_s[24]), y0_s[24]); + bit_met_s[24] = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + + xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[25], a_sq_s[25]), y0_s[25]); + bit_met_s[25] = simde_mm256_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); + + xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[26], a_sq_s[26]), y0_s[26]); + bit_met_s[26] = simde_mm256_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); + + xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[27], a_sq_s[27]), y0_s[27]); + bit_met_s[27] = simde_mm256_subs_epi16(xmm1, ch_mag_2_over_42_with_sigma2); + + xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[28], a_sq_s[28]), y0_s[28]); + bit_met_s[28] = simde_mm256_subs_epi16(xmm1, ch_mag_2_over_42_with_sigma2); + + xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[29], a_sq_s[29]), y0_s[29]); + bit_met_s[29] = simde_mm256_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); + + xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[30], a_sq_s[30]), y0_s[30]); + bit_met_s[30] = simde_mm256_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); + + xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[31], a_sq_s[31]), y0_s[31]); + bit_met_s[31] = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[32], a_sq_s[32]), y0_s[31]); + bit_met_s[32] = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + + xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[33], a_sq_s[33]), y0_s[30]); + bit_met_s[33] = simde_mm256_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); + + xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[34], a_sq_s[34]), y0_s[29]); + bit_met_s[34] = simde_mm256_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); + + xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[35], a_sq_s[35]), y0_s[28]); + bit_met_s[35] = simde_mm256_subs_epi16(xmm1, ch_mag_2_over_42_with_sigma2); + + xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[36], a_sq_s[36]), y0_s[27]); + bit_met_s[36] = simde_mm256_subs_epi16(xmm1, ch_mag_2_over_42_with_sigma2); + + xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[37], a_sq_s[37]), y0_s[26]); + bit_met_s[37] = simde_mm256_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); + + xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[38], a_sq_s[38]), y0_s[25]); + bit_met_s[38] = simde_mm256_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); + + xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[39], a_sq_s[39]), y0_s[24]); + bit_met_s[39] = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + + xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[40], a_sq_s[40]), y0_s[23]); + bit_met_s[40] = simde_mm256_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); + + xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[41], a_sq_s[41]), y0_s[22]); + bit_met_s[41] = simde_mm256_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); + + xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[42], a_sq_s[42]), y0_s[21]); + bit_met_s[42] = simde_mm256_subs_epi16(xmm1, ch_mag_18_over_42_with_sigma2); + + xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[43], a_sq_s[43]), y0_s[20]); + bit_met_s[43] = simde_mm256_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); + + xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[44], a_sq_s[44]), y0_s[19]); + bit_met_s[44] = simde_mm256_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); + + xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[45], a_sq_s[45]), y0_s[18]); + bit_met_s[45] = simde_mm256_subs_epi16(xmm1, ch_mag_18_over_42_with_sigma2); + + xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[46], a_sq_s[46]), y0_s[17]); + bit_met_s[46] = simde_mm256_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); + + xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[47], a_sq_s[47]), y0_s[16]); + bit_met_s[47] = simde_mm256_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); + + xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[48], a_sq_s[48]), y0_s[15]); + bit_met_s[48] = simde_mm256_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); + + xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[49], a_sq_s[49]), y0_s[14]); + bit_met_s[49] = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + + xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[50], a_sq_s[50]), y0_s[13]); + bit_met_s[50] = simde_mm256_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); + + xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[51], a_sq_s[51]), y0_s[12]); + bit_met_s[51] = simde_mm256_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); + + xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[52], a_sq_s[52]), y0_s[11]); + bit_met_s[52] = simde_mm256_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); + + xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[53], a_sq_s[53]), y0_s[10]); + bit_met_s[53] = simde_mm256_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); + + xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[54], a_sq_s[54]), y0_s[9]); + bit_met_s[54] = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + + xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[55], a_sq_s[55]), y0_s[8]); + bit_met_s[55] = simde_mm256_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); + + xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[56], a_sq_s[56]), y0_s[7]); + bit_met_s[56] = simde_mm256_subs_epi16(xmm1, ch_mag_98_over_42_with_sigma2); + + xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[57], a_sq_s[57]), y0_s[6]); + bit_met_s[57] = simde_mm256_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); + + xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[58], a_sq_s[58]), y0_s[5]); + bit_met_s[58] = simde_mm256_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); + + xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[59], a_sq_s[59]), y0_s[4]); + bit_met_s[59] = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + + xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[60], a_sq_s[60]), y0_s[3]); + bit_met_s[60] = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); + + xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[61], a_sq_s[61]), y0_s[2]); + bit_met_s[61] = simde_mm256_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); + + xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[62], a_sq_s[62]), y0_s[1]); + bit_met_s[62] = simde_mm256_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); + + xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[63], a_sq_s[63]), y0_s[0]); + bit_met_s[63] = simde_mm256_subs_epi16(xmm1, ch_mag_98_over_42_with_sigma2); + + // Detection for bits + simde__m256i logmax_den_re0; + simde__m256i logmax_num_re0; // Detection for 1st bit // bit = 1 - xmm0 = simde_mm256_max_epi16(bit_met_m7_p7, bit_met_m7_p5); - xmm1 = simde_mm256_max_epi16(bit_met_m7_p3, bit_met_m7_p1); - xmm2 = simde_mm256_max_epi16(bit_met_m7_m1, bit_met_m7_m3); - xmm3 = simde_mm256_max_epi16(bit_met_m7_m5, bit_met_m7_m7); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - simde__m256i logmax_den_re0 = simde_mm256_max_epi16(xmm4, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_m5_p7, bit_met_m5_p5); - xmm1 = simde_mm256_max_epi16(bit_met_m5_p3, bit_met_m5_p1); - xmm2 = simde_mm256_max_epi16(bit_met_m5_m1, bit_met_m5_m3); - xmm3 = simde_mm256_max_epi16(bit_met_m5_m5, bit_met_m5_m7); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_m3_p7, bit_met_m3_p5); - xmm1 = simde_mm256_max_epi16(bit_met_m3_p3, bit_met_m3_p1); - xmm2 = simde_mm256_max_epi16(bit_met_m3_m1, bit_met_m3_m3); - xmm3 = simde_mm256_max_epi16(bit_met_m3_m5, bit_met_m3_m7); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_m1_p7, bit_met_m1_p5); - xmm1 = simde_mm256_max_epi16(bit_met_m1_p3, bit_met_m1_p1); - xmm2 = simde_mm256_max_epi16(bit_met_m1_m1, bit_met_m1_m3); - xmm3 = simde_mm256_max_epi16(bit_met_m1_m5, bit_met_m1_m7); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm5); + xmm0 = max_epi16_256(bit_met_s[56],bit_met_s[57],bit_met_s[58],bit_met_s[59],bit_met_s[60],bit_met_s[61],bit_met_s[62],bit_met_s[63]); + xmm1 = max_epi16_256(bit_met_s[48],bit_met_s[49],bit_met_s[50],bit_met_s[51],bit_met_s[52],bit_met_s[53],bit_met_s[54],bit_met_s[55]); + xmm2 = max_epi16_256(bit_met_s[40],bit_met_s[41],bit_met_s[42],bit_met_s[43],bit_met_s[44],bit_met_s[45],bit_met_s[46],bit_met_s[47]); + xmm3 = max_epi16_256(bit_met_s[32],bit_met_s[33],bit_met_s[34],bit_met_s[35],bit_met_s[36],bit_met_s[37],bit_met_s[38],bit_met_s[39]); + logmax_den_re0 = simde_mm256_max_epi16(simde_mm256_max_epi16(xmm0, xmm1), simde_mm256_max_epi16(xmm2, xmm3)); // bit = 0 - xmm0 = simde_mm256_max_epi16(bit_met_p7_p7, bit_met_p7_p5); - xmm1 = simde_mm256_max_epi16(bit_met_p7_p3, bit_met_p7_p1); - xmm2 = simde_mm256_max_epi16(bit_met_p7_m1, bit_met_p7_m3); - xmm3 = simde_mm256_max_epi16(bit_met_p7_m5, bit_met_p7_m7); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - simde__m256i logmax_num_re0 = simde_mm256_max_epi16(xmm4, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_p5_p7, bit_met_p5_p5); - xmm1 = simde_mm256_max_epi16(bit_met_p5_p3, bit_met_p5_p1); - xmm2 = simde_mm256_max_epi16(bit_met_p5_m1, bit_met_p5_m3); - xmm3 = simde_mm256_max_epi16(bit_met_p5_m5, bit_met_p5_m7); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_p3_p7, bit_met_p3_p5); - xmm1 = simde_mm256_max_epi16(bit_met_p3_p3, bit_met_p3_p1); - xmm2 = simde_mm256_max_epi16(bit_met_p3_m1, bit_met_p3_m3); - xmm3 = simde_mm256_max_epi16(bit_met_p3_m5, bit_met_p3_m7); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_p1_p7, bit_met_p1_p5); - xmm1 = simde_mm256_max_epi16(bit_met_p1_p3, bit_met_p1_p1); - xmm2 = simde_mm256_max_epi16(bit_met_p1_m1, bit_met_p1_m3); - xmm3 = simde_mm256_max_epi16(bit_met_p1_m5, bit_met_p1_m7); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm5); + xmm0 = max_epi16_256(bit_met_s[0],bit_met_s[1],bit_met_s[2],bit_met_s[3],bit_met_s[4],bit_met_s[5],bit_met_s[6],bit_met_s[7]); + xmm1 = max_epi16_256(bit_met_s[8],bit_met_s[9],bit_met_s[10],bit_met_s[11],bit_met_s[12],bit_met_s[13],bit_met_s[14],bit_met_s[15]); + xmm2 = max_epi16_256(bit_met_s[16],bit_met_s[17],bit_met_s[18],bit_met_s[19],bit_met_s[20],bit_met_s[21],bit_met_s[22],bit_met_s[23]); + xmm3 = max_epi16_256(bit_met_s[24],bit_met_s[25],bit_met_s[26],bit_met_s[27],bit_met_s[28],bit_met_s[29],bit_met_s[30],bit_met_s[31]); + logmax_num_re0 = simde_mm256_max_epi16(simde_mm256_max_epi16(xmm0, xmm1), simde_mm256_max_epi16(xmm2, xmm3)); y0r = simde_mm256_subs_epi16(logmax_num_re0, logmax_den_re0); // Detection for 2nd bit // bit = 1 - xmm0 = simde_mm256_max_epi16(bit_met_p7_m1, bit_met_p5_m1); - xmm1 = simde_mm256_max_epi16(bit_met_p3_m1, bit_met_p1_m1); - xmm2 = simde_mm256_max_epi16(bit_met_m1_m1, bit_met_m3_m1); - xmm3 = simde_mm256_max_epi16(bit_met_m5_m1, bit_met_m7_m1); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm256_max_epi16(xmm4, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_p7_m3, bit_met_p5_m3); - xmm1 = simde_mm256_max_epi16(bit_met_p3_m3, bit_met_p1_m3); - xmm2 = simde_mm256_max_epi16(bit_met_m1_m3, bit_met_m3_m3); - xmm3 = simde_mm256_max_epi16(bit_met_m5_m3, bit_met_m7_m3); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_p7_m5, bit_met_p5_m5); - xmm1 = simde_mm256_max_epi16(bit_met_p3_m5, bit_met_p1_m5); - xmm2 = simde_mm256_max_epi16(bit_met_m1_m5, bit_met_m3_m5); - xmm3 = simde_mm256_max_epi16(bit_met_m5_m5, bit_met_m7_m5); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_p7_m7, bit_met_p5_m7); - xmm1 = simde_mm256_max_epi16(bit_met_p3_m7, bit_met_p1_m7); - xmm2 = simde_mm256_max_epi16(bit_met_m1_m7, bit_met_m3_m7); - xmm3 = simde_mm256_max_epi16(bit_met_m5_m7, bit_met_m7_m7); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm5); + xmm0 = max_epi16_256(bit_met_s[4],bit_met_s[12],bit_met_s[20],bit_met_s[28],bit_met_s[36],bit_met_s[44],bit_met_s[52],bit_met_s[60]); + xmm1 = max_epi16_256(bit_met_s[5],bit_met_s[13],bit_met_s[21],bit_met_s[29],bit_met_s[37],bit_met_s[45],bit_met_s[53],bit_met_s[61]); + xmm2 = max_epi16_256(bit_met_s[6],bit_met_s[14],bit_met_s[22],bit_met_s[30],bit_met_s[38],bit_met_s[46],bit_met_s[54],bit_met_s[62]); + xmm3 = max_epi16_256(bit_met_s[7],bit_met_s[15],bit_met_s[23],bit_met_s[31],bit_met_s[39],bit_met_s[47],bit_met_s[55],bit_met_s[63]); + logmax_den_re0 = simde_mm256_max_epi16(simde_mm256_max_epi16(xmm0, xmm1), simde_mm256_max_epi16(xmm2, xmm3)); // bit = 0 - xmm0 = simde_mm256_max_epi16(bit_met_p7_p1, bit_met_p5_p1); - xmm1 = simde_mm256_max_epi16(bit_met_p3_p1, bit_met_p1_p1); - xmm2 = simde_mm256_max_epi16(bit_met_m1_p1, bit_met_m3_p1); - xmm3 = simde_mm256_max_epi16(bit_met_m5_p1, bit_met_m7_p1); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm256_max_epi16(xmm4, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_p7_p3, bit_met_p5_p3); - xmm1 = simde_mm256_max_epi16(bit_met_p3_p3, bit_met_p1_p3); - xmm2 = simde_mm256_max_epi16(bit_met_m1_p3, bit_met_m3_p3); - xmm3 = simde_mm256_max_epi16(bit_met_m5_p3, bit_met_m7_p3); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_p7_p5, bit_met_p5_p5); - xmm1 = simde_mm256_max_epi16(bit_met_p3_p5, bit_met_p1_p5); - xmm2 = simde_mm256_max_epi16(bit_met_m1_p5, bit_met_m3_p5); - xmm3 = simde_mm256_max_epi16(bit_met_m5_p5, bit_met_m7_p5); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_p7_p7, bit_met_p5_p7); - xmm1 = simde_mm256_max_epi16(bit_met_p3_p7, bit_met_p1_p7); - xmm2 = simde_mm256_max_epi16(bit_met_m1_p7, bit_met_m3_p7); - xmm3 = simde_mm256_max_epi16(bit_met_m5_p7, bit_met_m7_p7); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm5); + xmm0 = max_epi16_256(bit_met_s[3],bit_met_s[11],bit_met_s[19],bit_met_s[27],bit_met_s[35],bit_met_s[43],bit_met_s[51],bit_met_s[59]); + xmm1 = max_epi16_256(bit_met_s[2],bit_met_s[10],bit_met_s[18],bit_met_s[26],bit_met_s[34],bit_met_s[42],bit_met_s[50],bit_met_s[58]); + xmm2 = max_epi16_256(bit_met_s[1],bit_met_s[9],bit_met_s[17],bit_met_s[25],bit_met_s[33],bit_met_s[41],bit_met_s[49],bit_met_s[57]); + xmm3 = max_epi16_256(bit_met_s[0],bit_met_s[8],bit_met_s[16],bit_met_s[24],bit_met_s[32],bit_met_s[40],bit_met_s[48],bit_met_s[56]); + logmax_num_re0 = simde_mm256_max_epi16(simde_mm256_max_epi16(xmm0, xmm1), simde_mm256_max_epi16(xmm2, xmm3)); y1r = simde_mm256_subs_epi16(logmax_num_re0, logmax_den_re0); // Detection for 3rd bit - xmm0 = simde_mm256_max_epi16(bit_met_m7_m7, bit_met_m7_m5); - xmm1 = simde_mm256_max_epi16(bit_met_m7_m3, bit_met_m7_m1); - xmm2 = simde_mm256_max_epi16(bit_met_m7_p1, bit_met_m7_p3); - xmm3 = simde_mm256_max_epi16(bit_met_m7_p5, bit_met_m7_p7); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm256_max_epi16(xmm4, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_m5_m7, bit_met_m5_m5); - xmm1 = simde_mm256_max_epi16(bit_met_m5_m3, bit_met_m5_m1); - xmm2 = simde_mm256_max_epi16(bit_met_m5_p1, bit_met_m5_p3); - xmm3 = simde_mm256_max_epi16(bit_met_m5_p5, bit_met_m5_p7); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_p5_m7, bit_met_p5_m5); - xmm1 = simde_mm256_max_epi16(bit_met_p5_m3, bit_met_p5_m1); - xmm2 = simde_mm256_max_epi16(bit_met_p5_p1, bit_met_p5_p3); - xmm3 = simde_mm256_max_epi16(bit_met_p5_p5, bit_met_p5_p7); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_p7_m7, bit_met_p7_m5); - xmm1 = simde_mm256_max_epi16(bit_met_p7_m3, bit_met_p7_m1); - xmm2 = simde_mm256_max_epi16(bit_met_p7_p1, bit_met_p7_p3); - xmm3 = simde_mm256_max_epi16(bit_met_p7_p5, bit_met_p7_p7); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm5); + xmm0 = max_epi16_256(bit_met_s[63],bit_met_s[62],bit_met_s[61],bit_met_s[60],bit_met_s[59],bit_met_s[58],bit_met_s[57],bit_met_s[56]); + xmm1 = max_epi16_256(bit_met_s[55],bit_met_s[54],bit_met_s[53],bit_met_s[52],bit_met_s[51],bit_met_s[50],bit_met_s[49],bit_met_s[48]); + xmm2 = max_epi16_256(bit_met_s[15],bit_met_s[14],bit_met_s[13],bit_met_s[12],bit_met_s[11],bit_met_s[10],bit_met_s[9],bit_met_s[8]); + xmm3 = max_epi16_256(bit_met_s[7],bit_met_s[6],bit_met_s[5],bit_met_s[4],bit_met_s[3],bit_met_s[2],bit_met_s[1],bit_met_s[0]); + logmax_den_re0 = simde_mm256_max_epi16(simde_mm256_max_epi16(xmm0, xmm1), simde_mm256_max_epi16(xmm2, xmm3)); - xmm0 = simde_mm256_max_epi16(bit_met_m3_m7, bit_met_m3_m5); - xmm1 = simde_mm256_max_epi16(bit_met_m3_m3, bit_met_m3_m1); - xmm2 = simde_mm256_max_epi16(bit_met_m3_p1, bit_met_m3_p3); - xmm3 = simde_mm256_max_epi16(bit_met_m3_p5, bit_met_m3_p7); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm256_max_epi16(xmm4, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_m1_m7, bit_met_m1_m5); - xmm1 = simde_mm256_max_epi16(bit_met_m1_m3, bit_met_m1_m1); - xmm2 = simde_mm256_max_epi16(bit_met_m1_p1, bit_met_m1_p3); - xmm3 = simde_mm256_max_epi16(bit_met_m1_p5, bit_met_m1_p7); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_p1_m7, bit_met_p1_m5); - xmm1 = simde_mm256_max_epi16(bit_met_p1_m3, bit_met_p1_m1); - xmm2 = simde_mm256_max_epi16(bit_met_p1_p1, bit_met_p1_p3); - xmm3 = simde_mm256_max_epi16(bit_met_p1_p5, bit_met_p1_p7); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_p3_m7, bit_met_p3_m5); - xmm1 = simde_mm256_max_epi16(bit_met_p3_m3, bit_met_p3_m1); - xmm2 = simde_mm256_max_epi16(bit_met_p3_p1, bit_met_p3_p3); - xmm3 = simde_mm256_max_epi16(bit_met_p3_p5, bit_met_p3_p7); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm5); + xmm0 = max_epi16_256(bit_met_s[47],bit_met_s[46],bit_met_s[45],bit_met_s[44],bit_met_s[43],bit_met_s[42],bit_met_s[41],bit_met_s[40]); + xmm1 = max_epi16_256(bit_met_s[39],bit_met_s[38],bit_met_s[37],bit_met_s[36],bit_met_s[35],bit_met_s[34],bit_met_s[33],bit_met_s[32]); + xmm2 = max_epi16_256(bit_met_s[31],bit_met_s[30],bit_met_s[29],bit_met_s[28],bit_met_s[27],bit_met_s[26],bit_met_s[25],bit_met_s[24]); + xmm3 = max_epi16_256(bit_met_s[23],bit_met_s[22],bit_met_s[21],bit_met_s[20],bit_met_s[19],bit_met_s[18],bit_met_s[17],bit_met_s[16]); + logmax_num_re0 = simde_mm256_max_epi16(simde_mm256_max_epi16(xmm0, xmm1), simde_mm256_max_epi16(xmm2, xmm3)); simde__m256i y2r = simde_mm256_subs_epi16(logmax_num_re0, logmax_den_re0); // Detection for 4th bit - xmm0 = simde_mm256_max_epi16(bit_met_p7_p7, bit_met_p5_p7); - xmm1 = simde_mm256_max_epi16(bit_met_p3_p7, bit_met_p1_p7); - xmm2 = simde_mm256_max_epi16(bit_met_m1_p7, bit_met_m3_p7); - xmm3 = simde_mm256_max_epi16(bit_met_m5_p7, bit_met_m7_p7); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm256_max_epi16(xmm4, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_p7_p5, bit_met_p5_p5); - xmm1 = simde_mm256_max_epi16(bit_met_p3_p5, bit_met_p1_p5); - xmm2 = simde_mm256_max_epi16(bit_met_m1_p5, bit_met_m3_p5); - xmm3 = simde_mm256_max_epi16(bit_met_m5_p5, bit_met_m5_p5); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_p7_m5, bit_met_p5_m5); - xmm1 = simde_mm256_max_epi16(bit_met_p3_m5, bit_met_p1_m5); - xmm2 = simde_mm256_max_epi16(bit_met_m1_m5, bit_met_m3_m5); - xmm3 = simde_mm256_max_epi16(bit_met_m5_m5, bit_met_m7_m5); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_p7_m7, bit_met_p5_m7); - xmm1 = simde_mm256_max_epi16(bit_met_p3_m7, bit_met_p1_m7); - xmm2 = simde_mm256_max_epi16(bit_met_m1_m7, bit_met_m3_m7); - xmm3 = simde_mm256_max_epi16(bit_met_m5_m7, bit_met_m7_m7); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm5); + xmm0 = max_epi16_256(bit_met_s[0],bit_met_s[8],bit_met_s[16],bit_met_s[24],bit_met_s[32],bit_met_s[40],bit_met_s[48],bit_met_s[56]); + xmm1 = max_epi16_256(bit_met_s[1],bit_met_s[9],bit_met_s[17],bit_met_s[25],bit_met_s[33],bit_met_s[41],bit_met_s[49],bit_met_s[49]); + xmm2 = max_epi16_256(bit_met_s[6],bit_met_s[14],bit_met_s[22],bit_met_s[30],bit_met_s[38],bit_met_s[46],bit_met_s[54],bit_met_s[62]); + xmm3 = max_epi16_256(bit_met_s[7],bit_met_s[15],bit_met_s[23],bit_met_s[31],bit_met_s[39],bit_met_s[47],bit_met_s[55],bit_met_s[63]); + logmax_den_re0 = simde_mm256_max_epi16(simde_mm256_max_epi16(xmm0, xmm1), simde_mm256_max_epi16(xmm2, xmm3)); - xmm0 = simde_mm256_max_epi16(bit_met_p7_m1, bit_met_p5_m1); - xmm1 = simde_mm256_max_epi16(bit_met_p3_m1, bit_met_p1_m1); - xmm2 = simde_mm256_max_epi16(bit_met_m1_m1, bit_met_m3_m1); - xmm3 = simde_mm256_max_epi16(bit_met_m5_m1, bit_met_m7_m1); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm256_max_epi16(xmm4, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_p7_m3, bit_met_p5_m3); - xmm1 = simde_mm256_max_epi16(bit_met_p3_m3, bit_met_p1_m3); - xmm2 = simde_mm256_max_epi16(bit_met_m1_m3, bit_met_m3_m3); - xmm3 = simde_mm256_max_epi16(bit_met_m5_m3, bit_met_m7_m3); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_p7_p1, bit_met_p5_p1); - xmm1 = simde_mm256_max_epi16(bit_met_p3_p1, bit_met_p1_p1); - xmm2 = simde_mm256_max_epi16(bit_met_m1_p1, bit_met_m3_p1); - xmm3 = simde_mm256_max_epi16(bit_met_m5_p1, bit_met_m7_p1); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_p7_p3, bit_met_p5_p3); - xmm1 = simde_mm256_max_epi16(bit_met_p3_p3, bit_met_p1_p3); - xmm2 = simde_mm256_max_epi16(bit_met_m1_p3, bit_met_m3_p3); - xmm3 = simde_mm256_max_epi16(bit_met_m5_p3, bit_met_m7_p3); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm5); + xmm0 = max_epi16_256(bit_met_s[4],bit_met_s[12],bit_met_s[20],bit_met_s[28],bit_met_s[36],bit_met_s[44],bit_met_s[52],bit_met_s[60]); + xmm1 = max_epi16_256(bit_met_s[5],bit_met_s[13],bit_met_s[21],bit_met_s[29],bit_met_s[37],bit_met_s[45],bit_met_s[53],bit_met_s[61]); + xmm2 = max_epi16_256(bit_met_s[3],bit_met_s[11],bit_met_s[19],bit_met_s[27],bit_met_s[35],bit_met_s[43],bit_met_s[51],bit_met_s[59]); + xmm3 = max_epi16_256(bit_met_s[2],bit_met_s[10],bit_met_s[18],bit_met_s[26],bit_met_s[34],bit_met_s[42],bit_met_s[50],bit_met_s[58]); + logmax_num_re0 = simde_mm256_max_epi16(simde_mm256_max_epi16(xmm0, xmm1), simde_mm256_max_epi16(xmm2, xmm3)); y0i = simde_mm256_subs_epi16(logmax_num_re0, logmax_den_re0); // Detection for 5th bit - xmm0 = simde_mm256_max_epi16(bit_met_m7_m7, bit_met_m7_m5); - xmm1 = simde_mm256_max_epi16(bit_met_m7_m3, bit_met_m7_m1); - xmm2 = simde_mm256_max_epi16(bit_met_m7_p1, bit_met_m7_p3); - xmm3 = simde_mm256_max_epi16(bit_met_m7_p5, bit_met_m7_p7); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm256_max_epi16(xmm4, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_m1_m7, bit_met_m1_m5); - xmm1 = simde_mm256_max_epi16(bit_met_m1_m3, bit_met_m1_m1); - xmm2 = simde_mm256_max_epi16(bit_met_m1_p1, bit_met_m1_p3); - xmm3 = simde_mm256_max_epi16(bit_met_m1_p5, bit_met_m1_p7); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_p1_m7, bit_met_p1_m5); - xmm1 = simde_mm256_max_epi16(bit_met_p1_m3, bit_met_p1_m1); - xmm2 = simde_mm256_max_epi16(bit_met_p1_p1, bit_met_p1_p3); - xmm3 = simde_mm256_max_epi16(bit_met_p1_p5, bit_met_p1_p7); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_p7_m7, bit_met_p7_m5); - xmm1 = simde_mm256_max_epi16(bit_met_p7_m3, bit_met_p7_m1); - xmm2 = simde_mm256_max_epi16(bit_met_p7_p1, bit_met_p7_p3); - xmm3 = simde_mm256_max_epi16(bit_met_p7_p5, bit_met_p7_p7); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm5); + xmm0 = max_epi16_256(bit_met_s[63],bit_met_s[62],bit_met_s[61],bit_met_s[60],bit_met_s[59],bit_met_s[58],bit_met_s[57],bit_met_s[56]); + xmm1 = max_epi16_256(bit_met_s[39],bit_met_s[38],bit_met_s[37],bit_met_s[36],bit_met_s[35],bit_met_s[34],bit_met_s[33],bit_met_s[32]); + xmm2 = max_epi16_256(bit_met_s[31],bit_met_s[30],bit_met_s[29],bit_met_s[28],bit_met_s[27],bit_met_s[26],bit_met_s[25],bit_met_s[24]); + xmm3 = max_epi16_256(bit_met_s[7],bit_met_s[6],bit_met_s[5],bit_met_s[4],bit_met_s[3],bit_met_s[2],bit_met_s[1],bit_met_s[0]); + logmax_den_re0 = simde_mm256_max_epi16(simde_mm256_max_epi16(xmm0, xmm1), simde_mm256_max_epi16(xmm2, xmm3)); - xmm0 = simde_mm256_max_epi16(bit_met_m5_m7, bit_met_m5_m5); - xmm1 = simde_mm256_max_epi16(bit_met_m5_m3, bit_met_m5_m1); - xmm2 = simde_mm256_max_epi16(bit_met_m5_p1, bit_met_m5_p3); - xmm3 = simde_mm256_max_epi16(bit_met_m5_p5, bit_met_m5_p7); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm256_max_epi16(xmm4, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_m3_m7, bit_met_m3_m5); - xmm1 = simde_mm256_max_epi16(bit_met_m3_m3, bit_met_m3_m1); - xmm2 = simde_mm256_max_epi16(bit_met_m3_p1, bit_met_m3_p3); - xmm3 = simde_mm256_max_epi16(bit_met_m3_p5, bit_met_m3_p7); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_p3_m7, bit_met_p3_m5); - xmm1 = simde_mm256_max_epi16(bit_met_p3_m3, bit_met_p3_m1); - xmm2 = simde_mm256_max_epi16(bit_met_p3_p1, bit_met_p3_p3); - xmm3 = simde_mm256_max_epi16(bit_met_p3_p5, bit_met_p3_p7); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_p5_m7, bit_met_p5_m5); - xmm1 = simde_mm256_max_epi16(bit_met_p5_m3, bit_met_p5_m1); - xmm2 = simde_mm256_max_epi16(bit_met_p5_p1, bit_met_p5_p3); - xmm3 = simde_mm256_max_epi16(bit_met_p5_p5, bit_met_p5_p7); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm5); + xmm0 = max_epi16_256(bit_met_s[55],bit_met_s[54],bit_met_s[53],bit_met_s[52],bit_met_s[51],bit_met_s[50],bit_met_s[49],bit_met_s[48]); + xmm1 = max_epi16_256(bit_met_s[47],bit_met_s[46],bit_met_s[45],bit_met_s[44],bit_met_s[43],bit_met_s[42],bit_met_s[41],bit_met_s[40]); + xmm2 = max_epi16_256(bit_met_s[23],bit_met_s[22],bit_met_s[21],bit_met_s[20],bit_met_s[19],bit_met_s[18],bit_met_s[17],bit_met_s[16]); + xmm3 = max_epi16_256(bit_met_s[15],bit_met_s[14],bit_met_s[13],bit_met_s[12],bit_met_s[11],bit_met_s[10],bit_met_s[9],bit_met_s[8]); + logmax_num_re0 = simde_mm256_max_epi16(simde_mm256_max_epi16(xmm0, xmm1), simde_mm256_max_epi16(xmm2, xmm3)); y1i = simde_mm256_subs_epi16(logmax_num_re0, logmax_den_re0); // Detection for 6th bit - xmm0 = simde_mm256_max_epi16(bit_met_p7_p7, bit_met_p5_p7); - xmm1 = simde_mm256_max_epi16(bit_met_p3_p7, bit_met_p1_p7); - xmm2 = simde_mm256_max_epi16(bit_met_m1_p7, bit_met_m3_p7); - xmm3 = simde_mm256_max_epi16(bit_met_m5_p7, bit_met_m7_p7); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm256_max_epi16(xmm4, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_p7_p1, bit_met_p5_p1); - xmm1 = simde_mm256_max_epi16(bit_met_p3_p1, bit_met_p1_p1); - xmm2 = simde_mm256_max_epi16(bit_met_m1_p1, bit_met_m3_p1); - xmm3 = simde_mm256_max_epi16(bit_met_m5_p1, bit_met_m5_p1); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_p7_m1, bit_met_p5_m1); - xmm1 = simde_mm256_max_epi16(bit_met_p3_m1, bit_met_p1_m1); - xmm2 = simde_mm256_max_epi16(bit_met_m1_m1, bit_met_m3_m1); - xmm3 = simde_mm256_max_epi16(bit_met_m5_m1, bit_met_m7_m1); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_p7_m7, bit_met_p5_m7); - xmm1 = simde_mm256_max_epi16(bit_met_p3_m7, bit_met_p1_m7); - xmm2 = simde_mm256_max_epi16(bit_met_m1_m7, bit_met_m3_m7); - xmm3 = simde_mm256_max_epi16(bit_met_m5_m7, bit_met_m7_m7); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm4); - logmax_den_re0 = simde_mm256_max_epi16(logmax_den_re0, xmm5); + xmm0 = max_epi16_256(bit_met_s[0],bit_met_s[8],bit_met_s[16],bit_met_s[24],bit_met_s[32],bit_met_s[40],bit_met_s[48],bit_met_s[56]); + xmm1 = max_epi16_256(bit_met_s[3],bit_met_s[11],bit_met_s[19],bit_met_s[27],bit_met_s[35],bit_met_s[43],bit_met_s[51],bit_met_s[51]); + xmm2 = max_epi16_256(bit_met_s[4],bit_met_s[12],bit_met_s[20],bit_met_s[28],bit_met_s[36],bit_met_s[44],bit_met_s[52],bit_met_s[60]); + xmm3 = max_epi16_256(bit_met_s[7],bit_met_s[15],bit_met_s[23],bit_met_s[31],bit_met_s[39],bit_met_s[47],bit_met_s[55],bit_met_s[63]); + logmax_den_re0 = simde_mm256_max_epi16(simde_mm256_max_epi16(xmm0, xmm1), simde_mm256_max_epi16(xmm2, xmm3)); - xmm0 = simde_mm256_max_epi16(bit_met_p7_m5, bit_met_p5_m5); - xmm1 = simde_mm256_max_epi16(bit_met_p3_m5, bit_met_p1_m5); - xmm2 = simde_mm256_max_epi16(bit_met_m1_m5, bit_met_m3_m5); - xmm3 = simde_mm256_max_epi16(bit_met_m5_m5, bit_met_m7_m5); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm256_max_epi16(xmm4, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_p7_m3, bit_met_p5_m3); - xmm1 = simde_mm256_max_epi16(bit_met_p3_m3, bit_met_p1_m3); - xmm2 = simde_mm256_max_epi16(bit_met_m1_m3, bit_met_m3_m3); - xmm3 = simde_mm256_max_epi16(bit_met_m5_m3, bit_met_m7_m3); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_p7_p3, bit_met_p5_p3); - xmm1 = simde_mm256_max_epi16(bit_met_p3_p3, bit_met_p1_p3); - xmm2 = simde_mm256_max_epi16(bit_met_m1_p3, bit_met_m3_p3); - xmm3 = simde_mm256_max_epi16(bit_met_m5_p3, bit_met_m7_p3); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm5); - xmm0 = simde_mm256_max_epi16(bit_met_p7_p5, bit_met_p5_p5); - xmm1 = simde_mm256_max_epi16(bit_met_p3_p5, bit_met_p1_p5); - xmm2 = simde_mm256_max_epi16(bit_met_m1_p5, bit_met_m3_p5); - xmm3 = simde_mm256_max_epi16(bit_met_m5_p5, bit_met_m7_p5); - xmm4 = simde_mm256_max_epi16(xmm0, xmm1); - xmm5 = simde_mm256_max_epi16(xmm2, xmm3); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm4); - logmax_num_re0 = simde_mm256_max_epi16(logmax_num_re0, xmm5); + xmm0 = max_epi16_256(bit_met_s[6],bit_met_s[14],bit_met_s[22],bit_met_s[30],bit_met_s[38],bit_met_s[46],bit_met_s[54],bit_met_s[62]); + xmm1 = max_epi16_256(bit_met_s[5],bit_met_s[13],bit_met_s[21],bit_met_s[29],bit_met_s[37],bit_met_s[45],bit_met_s[53],bit_met_s[61]); + xmm2 = max_epi16_256(bit_met_s[2],bit_met_s[10],bit_met_s[18],bit_met_s[26],bit_met_s[34],bit_met_s[42],bit_met_s[50],bit_met_s[58]); + xmm3 = max_epi16_256(bit_met_s[1],bit_met_s[9],bit_met_s[17],bit_met_s[25],bit_met_s[33],bit_met_s[41],bit_met_s[49],bit_met_s[57]); + logmax_num_re0 = simde_mm256_max_epi16(simde_mm256_max_epi16(xmm0, xmm1), simde_mm256_max_epi16(xmm2, xmm3)); simde__m256i y2i = simde_mm256_subs_epi16(logmax_num_re0, logmax_den_re0); From 0c4993249f59a4900b8d155f9460d0d811417b73 Mon Sep 17 00:00:00 2001 From: Quency Lin Date: Fri, 15 Sep 2023 00:16:10 +0200 Subject: [PATCH 18/47] fix: CI failure due to SIMD misalignment --- .../NR_TRANSPORT/nr_ulsch_llr_computation.c | 124 +++++++++--------- 1 file changed, 62 insertions(+), 62 deletions(-) diff --git a/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c b/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c index ba8904be11..fcd1c1b059 100644 --- a/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c +++ b/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c @@ -950,30 +950,30 @@ void nr_ulsch_qam16_qam16(c16_t *stream0_in, simde__m128i ch_mag_over_2; simde__m128i ch_mag_9_over_10; - simde__m128i xmm0 __attribute__((aligned(16))); - simde__m128i xmm1 __attribute__((aligned(16))); - simde__m128i xmm2 __attribute__((aligned(16))); - simde__m128i xmm3 __attribute__((aligned(16))); - simde__m128i xmm4 __attribute__((aligned(16))); - simde__m128i xmm5 __attribute__((aligned(16))); - simde__m128i xmm6 __attribute__((aligned(16))); - simde__m128i xmm7 __attribute__((aligned(16))); + simde__m128i xmm0; + simde__m128i xmm1; + simde__m128i xmm2; + simde__m128i xmm3; + simde__m128i xmm4; + simde__m128i xmm5; + simde__m128i xmm6; + simde__m128i xmm7; - simde__m128i rho_rpi __attribute__((aligned(16))); - simde__m128i rho_rmi __attribute__((aligned(16))); - simde__m128i rho_rs[8] __attribute__((aligned(16))); - simde__m128i psi_rs[16] __attribute__((aligned(16))); - simde__m128i psi_is[16] __attribute__((aligned(16))); - simde__m128i a_rs[16] __attribute__((aligned(16))); - simde__m128i a_is[16] __attribute__((aligned(16))); - simde__m128i psi_as[16] __attribute__((aligned(16))); - simde__m128i a_sqs[16] __attribute__((aligned(16))); - simde__m128i y0_s[8] __attribute__((aligned(16))); + simde__m128i rho_rpi; + simde__m128i rho_rmi; + simde__m128i rho_rs[8]; + simde__m128i psi_rs[16]; + simde__m128i psi_is[16]; + simde__m128i a_rs[16]; + simde__m128i a_is[16]; + simde__m128i psi_as[16]; + simde__m128i a_sqs[16]; + simde__m128i y0_s[8]; - simde__m128i y0r __attribute__((aligned(16))); - simde__m128i y0i __attribute__((aligned(16))); - simde__m128i y1r __attribute__((aligned(16))); - simde__m128i y1i __attribute__((aligned(16))); + simde__m128i y0r; + simde__m128i y0i; + simde__m128i y1r; + simde__m128i y1i; // In one iteration, we deal with 8 REs for (int i = 0; i < length >> 2; i += 2) { @@ -1070,7 +1070,7 @@ void nr_ulsch_qam16_qam16(c16_t *stream0_in, ch_mag_9_over_10 = simde_mm_slli_epi16(ch_mag_9_over_10, 2); /// Compute bit metrics (lambda) - simde__m128i bit_mets[16] __attribute__((aligned(16))); + simde__m128i bit_mets[16]; for(int j=0; j<8; j+=4){ bit_mets[j+0] = simde_mm_subs_epi16(psi_as[j+0], a_sqs[j+0]); bit_mets[j+0] = simde_mm_adds_epi16(bit_mets[j+0], y0_s[j+0]); @@ -1163,28 +1163,28 @@ void nr_ulsch_qam16_qam16(c16_t *stream0_in, simde__m256i ch_mag_over_2; simde__m256i ch_mag_9_over_10; - simde__m256i xmm2 __attribute__((aligned(16))); - simde__m256i xmm3 __attribute__((aligned(16))); - simde__m256i xmm4 __attribute__((aligned(16))); - simde__m256i xmm5 __attribute__((aligned(16))); - simde__m256i xmm6 __attribute__((aligned(16))); - simde__m256i xmm7 __attribute__((aligned(16))); + simde__m256i xmm2; + simde__m256i xmm3; + simde__m256i xmm4; + simde__m256i xmm5; + simde__m256i xmm6; + simde__m256i xmm7; - simde__m256i rho_rpi __attribute__((aligned(16))); - simde__m256i rho_rmi __attribute__((aligned(16))); - simde__m256i rho_rs[8] __attribute__((aligned(16))); - simde__m256i psi_rs[16] __attribute__((aligned(16))); - simde__m256i psi_is[16] __attribute__((aligned(16))); - simde__m256i a_rs[16] __attribute__((aligned(16))); - simde__m256i a_is[16] __attribute__((aligned(16))); - simde__m256i psi_as[16] __attribute__((aligned(16))); - simde__m256i a_sqs[16] __attribute__((aligned(16))); - simde__m256i y0_s[8] __attribute__((aligned(16))); + simde__m256i rho_rpi; + simde__m256i rho_rmi; + simde__m256i rho_rs[8]; + simde__m256i psi_rs[16]; + simde__m256i psi_is[16]; + simde__m256i a_rs[16]; + simde__m256i a_is[16]; + simde__m256i psi_as[16]; + simde__m256i a_sqs[16]; + simde__m256i y0_s[8]; - simde__m256i y0r __attribute__((aligned(16))); - simde__m256i y0i __attribute__((aligned(16))); - simde__m256i y1r __attribute__((aligned(16))); - simde__m256i y1i __attribute__((aligned(16))); + simde__m256i y0r; + simde__m256i y0i; + simde__m256i y1r; + simde__m256i y1i; // In one iteration, we deal with 8 REs for (int i = 0; i < length >> 3; i += 2) { @@ -1282,7 +1282,7 @@ void nr_ulsch_qam16_qam16(c16_t *stream0_in, /// Compute bit metrics (lambda) - simde__m256i bit_mets[16] __attribute__((aligned(16))); + simde__m256i bit_mets[16]; for(int j=0; j<8; j+=4){ bit_mets[j+0] = simde_mm256_subs_epi16(psi_as[j+0], a_sqs[j+0]); bit_mets[j+0] = simde_mm256_adds_epi16(bit_mets[j+0], y0_s[j+0]); @@ -1454,7 +1454,7 @@ void nr_ulsch_qam64_qam64(c16_t *stream0_in, simde__m128i rho_rmi = simde_mm_subs_epi16(xmm2, xmm3); // rho* = Re(rho) - Im(rho) // Compute the different rhos - simde__m128i rho_rs[32] __attribute__((aligned(16))); + simde__m128i rho_rs[32]; rho_rs[27] = simde_mm_mulhi_epi16(rho_rpi, ONE_OVER_SQRT_42); rho_rs[28] = simde_mm_mulhi_epi16(rho_rmi, ONE_OVER_SQRT_42); rho_rs[18] = simde_mm_mulhi_epi16(rho_rpi, THREE_OVER_SQRT_42); @@ -1518,14 +1518,14 @@ void nr_ulsch_qam64_qam64(c16_t *stream0_in, xmm0 = simde_mm_set1_epi16(0); // ZERO for abs_pi16 xmm2 = simde_mm_subs_epi16(rho_rs[0], y1r); - simde__m128i psi_r_s[64] __attribute__((aligned(16))); + simde__m128i psi_r_s[64]; for(int j=0; j<32; j++) // psi_r_s[0~31], rho_rs[0~31] psi_r_s[j] = simde_mm_abs_epi16(simde_mm_subs_epi16(rho_rs[j], y1r)); for(int j=32; j<64; j++) // psi_r_s[32~64], rho_rs[31~0] psi_r_s[j] = simde_mm_abs_epi16(simde_mm_adds_epi16(rho_rs[63 - j], y1r)); // simde__m128i psi_i calculation from rho_rpi or rho_rmi - simde__m128i psi_i_s[64] __attribute__((aligned(16))); + simde__m128i psi_i_s[64]; const uint8_t rho_rs_index[32] = {7,15,23,31,24,16,8,0,6,14,22,30,25,17,9,1,5,13,21,29,26,18,10,2,4,12,20,28,27,19,11,3}; for(int k=0; k<32; k+=8){ // psi_i_s[0~31] for(int j=k; j>3], y0i_seven_over_sqrt_21); @@ -1582,10 +1582,10 @@ void nr_ulsch_qam64_qam64(c16_t *stream0_in, ch_mag_int_with_sigma2 = simde_mm_srai_epi16(ch_mag_int, 1); // *2 two_ch_mag_int_with_sigma2 = ch_mag_int; // *4 three_ch_mag_int_with_sigma2 = simde_mm_adds_epi16(ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2); // *6 - simde__m128i a_r_s[64] __attribute__((aligned(16))); - simde__m128i a_i_s[64] __attribute__((aligned(16))); - simde__m128i psi_a_s[64] __attribute__((aligned(16))); - simde__m128i a_sq_s[64] __attribute__((aligned(16))); + simde__m128i a_r_s[64]; + simde__m128i a_i_s[64]; + simde__m128i psi_a_s[64]; + simde__m128i a_sq_s[64]; for(int j=0; j<64; j++){ // Detection of interference term a_r_s[j] = interference_abs_64qam_epi16(psi_r_s[j], ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); @@ -1634,7 +1634,7 @@ void nr_ulsch_qam64_qam64(c16_t *stream0_in, ch_mag_98_over_42_with_sigma2 = simde_mm_slli_epi16(ch_mag_98_over_42_with_sigma2, 2); // Computing Metrics - simde__m128i bit_met_s[64] __attribute__((aligned(16))); + simde__m128i bit_met_s[64]; xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[0], a_sq_s[0]), y0_s[0]); bit_met_s[0] = simde_mm_subs_epi16(xmm1, ch_mag_98_over_42_with_sigma2); @@ -1997,7 +1997,7 @@ void nr_ulsch_qam64_qam64(c16_t *stream0_in, simde__m256i rho_rmi = simde_mm256_subs_epi16(xmm2, xmm3); // rho* = Re(rho) - Im(rho) // Compute the different rhos - simde__m256i rho_rs[32] __attribute__((aligned(16))); + simde__m256i rho_rs[32]; rho_rs[27] = simde_mm256_mulhi_epi16(rho_rpi, ONE_OVER_SQRT_42); rho_rs[28] = simde_mm256_mulhi_epi16(rho_rmi, ONE_OVER_SQRT_42); rho_rs[18] = simde_mm256_mulhi_epi16(rho_rpi, THREE_OVER_SQRT_42); @@ -2061,14 +2061,14 @@ void nr_ulsch_qam64_qam64(c16_t *stream0_in, xmm0 = simde_mm256_broadcastw_epi16(simde_mm_set1_epi16(0)); // ZERO for abs_pi16 xmm2 = simde_mm256_subs_epi16(rho_rs[0], y1r); - simde__m256i psi_r_s[64] __attribute__((aligned(16))); + simde__m256i psi_r_s[64]; for(int j=0; j<32; j++) // psi_r_s[0~31], rho_rs[0~31] psi_r_s[j] = simde_mm256_abs_epi16(simde_mm256_subs_epi16(rho_rs[j], y1r)); for(int j=32; j<64; j++) // psi_r_s[32~64], rho_rs[31~0] psi_r_s[j] = simde_mm256_abs_epi16(simde_mm256_adds_epi16(rho_rs[63 - j], y1r)); // simde__m256i psi_i calculation from rho_rpi or rho_rmi - simde__m256i psi_i_s[64] __attribute__((aligned(16))); + simde__m256i psi_i_s[64]; const uint8_t rho_rs_index[32] = {7,15,23,31,24,16,8,0,6,14,22,30,25,17,9,1,5,13,21,29,26,18,10,2,4,12,20,28,27,19,11,3}; for(int k=0; k<32; k+=8){ // psi_i_s[0~31] for(int j=k; j>3], y0i_seven_over_sqrt_21); @@ -2125,10 +2125,10 @@ void nr_ulsch_qam64_qam64(c16_t *stream0_in, ch_mag_int_with_sigma2 = simde_mm256_srai_epi16(ch_mag_int, 1); // *2 two_ch_mag_int_with_sigma2 = ch_mag_int; // *4 three_ch_mag_int_with_sigma2 = simde_mm256_adds_epi16(ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2); // *6 - simde__m256i a_r_s[64] __attribute__((aligned(16))); - simde__m256i a_i_s[64] __attribute__((aligned(16))); - simde__m256i psi_a_s[64] __attribute__((aligned(16))); - simde__m256i a_sq_s[64] __attribute__((aligned(16))); + simde__m256i a_r_s[64]; + simde__m256i a_i_s[64]; + simde__m256i psi_a_s[64]; + simde__m256i a_sq_s[64]; for(int j=0; j<64; j++){ // Detection of interference term a_r_s[j] = interference_abs_64qam_epi16_256(psi_r_s[j], ch_mag_int_with_sigma2, two_ch_mag_int_with_sigma2, three_ch_mag_int_with_sigma2, ONE_OVER_SQRT_2_42, THREE_OVER_SQRT_2_42, FIVE_OVER_SQRT_2_42, SEVEN_OVER_SQRT_2_42); @@ -2177,7 +2177,7 @@ void nr_ulsch_qam64_qam64(c16_t *stream0_in, ch_mag_98_over_42_with_sigma2 = simde_mm256_slli_epi16(ch_mag_98_over_42_with_sigma2, 2); // Computing Metrics - simde__m256i bit_met_s[64] __attribute__((aligned(16))); + simde__m256i bit_met_s[64]; xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[0], a_sq_s[0]), y0_s[0]); bit_met_s[0] = simde_mm256_subs_epi16(xmm1, ch_mag_98_over_42_with_sigma2); From 7d6a955b49032540a051dd3adb23d845f55415b7 Mon Sep 17 00:00:00 2001 From: Quency Lin Date: Mon, 25 Sep 2023 22:30:18 +0200 Subject: [PATCH 19/47] Fix: variable typo when referencing --- openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c b/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c index fcd1c1b059..bc88a15328 100644 --- a/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c +++ b/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c @@ -278,7 +278,7 @@ void nr_ulsch_256qam_llr(int32_t *rxdataF_comp, simde__m64 *ch_magc = (simde__m64*)&ul_ch_magc[(symbol*(off+(nb_rb*12)))]; xmm0 = simde_mm_abs_pi16(rxF[nb_re64-1]); // registers of even index in xmm0-> |y_R|, registers of odd index in xmm0-> |y_I| - xmm0 = simde_mm_subs_pi16(ch_mag[nb_re-1],xmm0); // registers of even index in xmm0-> |y_R|-|h|^2, registers of odd index in xmm0-> |y_I|-|h|^2 + xmm0 = simde_mm_subs_pi16(ch_mag[nb_re64-1],xmm0); // registers of even index in xmm0-> |y_R|-|h|^2, registers of odd index in xmm0-> |y_I|-|h|^2 // xmmtmpD2 contains 4 LLRs xmm1 = simde_mm_abs_pi16(xmm0); xmm1 = simde_mm_subs_pi16(ch_magb[nb_re64-1],xmm1); // contains 4 LLRs From e8bcd1882c885792f07b0b2ac493fabcda33eed9 Mon Sep 17 00:00:00 2001 From: Quency Lin Date: Mon, 25 Sep 2023 23:26:20 +0200 Subject: [PATCH 20/47] Refactor: minor refactors * [x] `register simde__m128i xmm0;` -\> `simde__m128i xmm0;` * [x] `simde__m128i xmm0 = simde_mm_abs_epi16(rxF\[i\]);` declaration in for loop * [x] `int nb_re64 = nb_re >> 1;` would be better as `int last2re = (nb_re >> 1) - 1;` * [x] `simde_m_punpckhdq()` is better known as `simde_mm_unpackhi_pi32()` --- .../NR_TRANSPORT/nr_ulsch_llr_computation.c | 25 +++++++++---------- 1 file changed, 12 insertions(+), 13 deletions(-) diff --git a/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c b/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c index bc88a15328..d5843d9181 100644 --- a/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c +++ b/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c @@ -70,7 +70,6 @@ void nr_ulsch_16qam_llr(int32_t *rxdataF_comp, simde__m128i *rxF = (simde__m128i*)rxdataF_comp; simde__m128i *ch_mag; simde__m128i llr128[2]; - register simde__m128i xmm0; simde__m64 *llr64 = (simde__m64*) ulsch_llr; int i; int nb_rb = nb_re / NR_NB_SC_PER_RB; @@ -82,7 +81,7 @@ void nr_ulsch_16qam_llr(int32_t *rxdataF_comp, // Each iteration does 4 RE (gives 16 16bit-llrs) for (i=0; i |y_R|, registers of odd index in xmm0-> |y_I| + simde__m128i xmm0 = simde_mm_abs_epi16(rxF[i]); // registers of even index in xmm0-> |y_R|, registers of odd index in xmm0-> |y_I| xmm0 = simde_mm_subs_epi16(ch_mag[i],xmm0); // registers of even index in xmm0-> |y_R|-|h|^2, registers of odd index in xmm0-> |y_I|-|h|^2 llr128[0] = simde_mm_unpacklo_epi32(rxF[i],xmm0); // llr128[0] contains the llrs of the 1st,2nd,5th and 6th REs @@ -142,7 +141,6 @@ void nr_ulsch_64qam_llr(int32_t *rxdataF_comp, simde__m128i *rxF = (simde__m128i*)rxdataF_comp; simde__m128i *ch_mag,*ch_magb; - register simde__m128i xmm0,xmm1,xmm2; int i; ch_mag = (simde__m128i*)&ul_ch_mag[(symbol*(off+(nb_rb*12)))]; ch_magb = (simde__m128i*)&ul_ch_magb[(symbol*(off+(nb_rb*12)))]; @@ -153,6 +151,7 @@ void nr_ulsch_64qam_llr(int32_t *rxdataF_comp, // Each iteration does 4 RE (gives 24 16bit-llrs) for (i=0; i> 2; // length in 128-bit words (4 REs) for (int i=0; i |y_R|, registers of odd index in xmm0-> |y_I| xmm0 = simde_mm_subs_epi16(ch_mag[i], xmm0); // registers of even index in xmm0-> |y_R|-|h|^2, registers of odd index in xmm0-> |y_I|-|h|^2 xmm1 = simde_mm_abs_epi16(xmm0); @@ -269,7 +268,7 @@ void nr_ulsch_256qam_llr(int32_t *rxdataF_comp, if (len_mod4) { printf("len_mod4=%d\n", len_mod4); - int nb_re64 = nb_re >> 1; + int last_2_re = (nb_re >> 1) - 1; simde__m64 *llr64 = (simde__m64 *)llr128; simde__m64 xmm0,xmm1,xmm2; simde__m64 *rxF = (simde__m64*)rxdataF_comp; @@ -277,21 +276,21 @@ void nr_ulsch_256qam_llr(int32_t *rxdataF_comp, simde__m64 *ch_magb = (simde__m64*)&ul_ch_magb[(symbol*(off+(nb_rb*12)))]; simde__m64 *ch_magc = (simde__m64*)&ul_ch_magc[(symbol*(off+(nb_rb*12)))]; - xmm0 = simde_mm_abs_pi16(rxF[nb_re64-1]); // registers of even index in xmm0-> |y_R|, registers of odd index in xmm0-> |y_I| - xmm0 = simde_mm_subs_pi16(ch_mag[nb_re64-1],xmm0); // registers of even index in xmm0-> |y_R|-|h|^2, registers of odd index in xmm0-> |y_I|-|h|^2 + xmm0 = simde_mm_abs_pi16(rxF[last_2_re]); // registers of even index in xmm0-> |y_R|, registers of odd index in xmm0-> |y_I| + xmm0 = simde_mm_subs_pi16(ch_mag[last_2_re],xmm0); // registers of even index in xmm0-> |y_R|-|h|^2, registers of odd index in xmm0-> |y_I|-|h|^2 // xmmtmpD2 contains 4 LLRs xmm1 = simde_mm_abs_pi16(xmm0); - xmm1 = simde_mm_subs_pi16(ch_magb[nb_re64-1],xmm1); // contains 4 LLRs + xmm1 = simde_mm_subs_pi16(ch_magb[last_2_re],xmm1); // contains 4 LLRs xmm2 = simde_mm_abs_pi16(xmm1); - xmm2 = simde_mm_subs_pi16(ch_magc[nb_re64-1],xmm2); // contains 4 LLRs + xmm2 = simde_mm_subs_pi16(ch_magc[last_2_re],xmm2); // contains 4 LLRs // rxF[i] A0 A1 // xmm0 B0 B1 // xmm1 C0 C1 // xmm2 D0 D1 - llr64[0] = simde_m_punpckldq(rxF[nb_re64-1],xmm0); // A0 B0 - llr64[2] = simde_m_punpckhdq(rxF[nb_re64-1],xmm0); // A1 B1 - llr64[1] = simde_m_punpckldq(xmm1,xmm2); // C0 D0 - llr64[3] = simde_m_punpckhdq(xmm1,xmm2); // C1 D1 + llr64[0] = simde_mm_unpacklo_pi32(rxF[last_2_re],xmm0); // A0 B0 + llr64[2] = simde_mm_unpackhi_pi32(rxF[last_2_re],xmm0); // A1 B1 + llr64[1] = simde_mm_unpacklo_pi32(xmm1,xmm2); // C0 D0 + llr64[3] = simde_mm_unpackhi_pi32(xmm1,xmm2); // C1 D1 } #else simde__m256i *rxF = (simde__m256i*)rxdataF_comp; From 8b1f42423b878330990caa1d76eeb5ed6a2e539e Mon Sep 17 00:00:00 2001 From: Quency Lin Date: Tue, 26 Sep 2023 01:09:45 +0200 Subject: [PATCH 21/47] Refactor: 16QAM LLR 128 SIMDe assign --- .../PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c | 15 ++++----------- 1 file changed, 4 insertions(+), 11 deletions(-) diff --git a/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c b/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c index d5843d9181..320bc0fcda 100644 --- a/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c +++ b/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c @@ -69,8 +69,7 @@ void nr_ulsch_16qam_llr(int32_t *rxdataF_comp, #ifdef USE_128BIT simde__m128i *rxF = (simde__m128i*)rxdataF_comp; simde__m128i *ch_mag; - simde__m128i llr128[2]; - simde__m64 *llr64 = (simde__m64*) ulsch_llr; + simde__m128i *ulsch_llr_128 = (simde__m128i*) ulsch_llr; int i; int nb_rb = nb_re / NR_NB_SC_PER_RB; int off = ((nb_rb&1) == 1)? 4:0; @@ -84,15 +83,9 @@ void nr_ulsch_16qam_llr(int32_t *rxdataF_comp, simde__m128i xmm0 = simde_mm_abs_epi16(rxF[i]); // registers of even index in xmm0-> |y_R|, registers of odd index in xmm0-> |y_I| xmm0 = simde_mm_subs_epi16(ch_mag[i],xmm0); // registers of even index in xmm0-> |y_R|-|h|^2, registers of odd index in xmm0-> |y_I|-|h|^2 - llr128[0] = simde_mm_unpacklo_epi32(rxF[i],xmm0); // llr128[0] contains the llrs of the 1st,2nd,5th and 6th REs - llr128[1] = simde_mm_unpackhi_epi32(rxF[i],xmm0); // llr128[1] contains the llrs of the 3rd, 4th, 7th and 8th REs - - llr64[0] = (simde__m64)simde_mm_extract_epi64(llr128[0], 0); // llr32[0] low 16 bits-> y_R, high 16 bits-> y_I - llr64[1] = (simde__m64)simde_mm_extract_epi64(llr128[0], 1); // llr32[2] low 16 bits-> y_R, high 16 bits-> y_I - llr64[2] = (simde__m64)simde_mm_extract_epi64(llr128[1], 0); // llr32[4] low 16 bits-> y_R, high 16 bits-> y_I - llr64[3] = (simde__m64)simde_mm_extract_epi64(llr128[1], 1); // llr32[6] low 16 bits-> y_R, high 16 bits-> y_I - - llr64 += 4; + ulsch_llr_128[0] = simde_mm_unpacklo_epi32(rxF[i],xmm0); // llr128[0] contains the llrs of the 1st,2nd,5th and 6th REs + ulsch_llr_128[1] = simde_mm_unpackhi_epi32(rxF[i],xmm0); // llr128[1] contains the llrs of the 3rd, 4th, 7th and 8th REs + ulsch_llr_128 += 2; } #else simde__m256i *rxF_256 = (simde__m256i*)rxdataF_comp; From 058eb64ed9340ff03909914bb0aa1acf03c93299 Mon Sep 17 00:00:00 2001 From: Raphael Defosseux Date: Wed, 27 Sep 2023 16:24:25 +0200 Subject: [PATCH 22/47] chore(ci): adapting to new python build framework. Signed-off-by: Raphael Defosseux --- docker/Dockerfile.build.ubuntu20.cross-arm64 | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docker/Dockerfile.build.ubuntu20.cross-arm64 b/docker/Dockerfile.build.ubuntu20.cross-arm64 index 058d9a091f..b5f770a485 100644 --- a/docker/Dockerfile.build.ubuntu20.cross-arm64 +++ b/docker/Dockerfile.build.ubuntu20.cross-arm64 @@ -34,14 +34,14 @@ COPY . . # build all targets so final targets can be created afterwards RUN /bin/sh oaienv && \ cd cmake_targets && \ - mkdir -p ran_build/build ran_build/build-cross && \ + mkdir -p log ran_build/build ran_build/build-cross && \ cd ran_build/build && \ cmake ../../.. -GNinja && \ echo "====== Start of log for host-tools ======" && \ - ninja ldpc_generators generate_T && \ + ninja ldpc_generators generate_T > ../../log/host-tools.txt 2>&1 && \ echo "====== End of log for host-tools ======" && \ cd ../build-cross/ && \ cmake ../../.. -GNinja -DCMAKE_TOOLCHAIN_FILE=../../../cmake_targets/cross-arm.cmake -DNATIVE_DIR=../build && \ echo "====== Start of log for cross-build executables ======" && \ - ninja dlsim ulsim ldpctest polartest smallblocktest nr_pbchsim nr_dlschsim nr_ulschsim nr_dlsim nr_ulsim nr_pucchsim nr_prachsim lte-softmodem nr-softmodem nr-cuup oairu lte-uesoftmodem nr-uesoftmodem params_libconfig coding rfsimulator && \ + ninja dlsim ulsim ldpctest polartest smallblocktest nr_pbchsim nr_dlschsim nr_ulschsim nr_dlsim nr_ulsim nr_pucchsim nr_prachsim lte-softmodem nr-softmodem nr-cuup oairu lte-uesoftmodem nr-uesoftmodem params_libconfig coding rfsimulator > ../../log/all.txt 2>&1 && \ echo "====== End of log for cross-build executables ======" From 54248431906490790233986a5f1f7d581406f33e Mon Sep 17 00:00:00 2001 From: Quency Lin Date: Tue, 3 Oct 2023 09:37:45 +0200 Subject: [PATCH 23/47] misc: remove debug print and fix wrong index accessing array Before this MR, openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c: nr_ulsch_qam64_qam64(): xmm3 = simde_mm256_max_epi16(bit_met_m5_p1, bit_met_m5_p1); Should be instead: xmm3 = simde_mm256_max_epi16(bit_met_m5_p1, bit_met_m7_p1); --- openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c b/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c index 320bc0fcda..f2796b35ce 100644 --- a/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c +++ b/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c @@ -260,7 +260,6 @@ void nr_ulsch_256qam_llr(int32_t *rxdataF_comp, } if (len_mod4) { - printf("len_mod4=%d\n", len_mod4); int last_2_re = (nb_re >> 1) - 1; simde__m64 *llr64 = (simde__m64 *)llr128; simde__m64 xmm0,xmm1,xmm2; @@ -1872,7 +1871,7 @@ void nr_ulsch_qam64_qam64(c16_t *stream0_in, // Detection for 4th bit xmm0 = max_epi16(bit_met_s[0],bit_met_s[8],bit_met_s[16],bit_met_s[24],bit_met_s[32],bit_met_s[40],bit_met_s[48],bit_met_s[56]); - xmm1 = max_epi16(bit_met_s[1],bit_met_s[9],bit_met_s[17],bit_met_s[25],bit_met_s[33],bit_met_s[41],bit_met_s[49],bit_met_s[49]); + xmm1 = max_epi16(bit_met_s[1],bit_met_s[9],bit_met_s[17],bit_met_s[25],bit_met_s[33],bit_met_s[41],bit_met_s[49],bit_met_s[57]); xmm2 = max_epi16(bit_met_s[6],bit_met_s[14],bit_met_s[22],bit_met_s[30],bit_met_s[38],bit_met_s[46],bit_met_s[54],bit_met_s[62]); xmm3 = max_epi16(bit_met_s[7],bit_met_s[15],bit_met_s[23],bit_met_s[31],bit_met_s[39],bit_met_s[47],bit_met_s[55],bit_met_s[63]); logmax_den_re0 = simde_mm_max_epi16(simde_mm_max_epi16(xmm0, xmm1), simde_mm_max_epi16(xmm2, xmm3)); @@ -1902,7 +1901,7 @@ void nr_ulsch_qam64_qam64(c16_t *stream0_in, // Detection for 6th bit xmm0 = max_epi16(bit_met_s[0],bit_met_s[8],bit_met_s[16],bit_met_s[24],bit_met_s[32],bit_met_s[40],bit_met_s[48],bit_met_s[56]); - xmm1 = max_epi16(bit_met_s[3],bit_met_s[11],bit_met_s[19],bit_met_s[27],bit_met_s[35],bit_met_s[43],bit_met_s[51],bit_met_s[51]); + xmm1 = max_epi16(bit_met_s[3],bit_met_s[11],bit_met_s[19],bit_met_s[27],bit_met_s[35],bit_met_s[43],bit_met_s[51],bit_met_s[59]); xmm2 = max_epi16(bit_met_s[4],bit_met_s[12],bit_met_s[20],bit_met_s[28],bit_met_s[36],bit_met_s[44],bit_met_s[52],bit_met_s[60]); xmm3 = max_epi16(bit_met_s[7],bit_met_s[15],bit_met_s[23],bit_met_s[31],bit_met_s[39],bit_met_s[47],bit_met_s[55],bit_met_s[63]); logmax_den_re0 = simde_mm_max_epi16(simde_mm_max_epi16(xmm0, xmm1), simde_mm_max_epi16(xmm2, xmm3)); @@ -2416,7 +2415,7 @@ void nr_ulsch_qam64_qam64(c16_t *stream0_in, // Detection for 4th bit xmm0 = max_epi16_256(bit_met_s[0],bit_met_s[8],bit_met_s[16],bit_met_s[24],bit_met_s[32],bit_met_s[40],bit_met_s[48],bit_met_s[56]); - xmm1 = max_epi16_256(bit_met_s[1],bit_met_s[9],bit_met_s[17],bit_met_s[25],bit_met_s[33],bit_met_s[41],bit_met_s[49],bit_met_s[49]); + xmm1 = max_epi16_256(bit_met_s[1],bit_met_s[9],bit_met_s[17],bit_met_s[25],bit_met_s[33],bit_met_s[41],bit_met_s[49],bit_met_s[57]); xmm2 = max_epi16_256(bit_met_s[6],bit_met_s[14],bit_met_s[22],bit_met_s[30],bit_met_s[38],bit_met_s[46],bit_met_s[54],bit_met_s[62]); xmm3 = max_epi16_256(bit_met_s[7],bit_met_s[15],bit_met_s[23],bit_met_s[31],bit_met_s[39],bit_met_s[47],bit_met_s[55],bit_met_s[63]); logmax_den_re0 = simde_mm256_max_epi16(simde_mm256_max_epi16(xmm0, xmm1), simde_mm256_max_epi16(xmm2, xmm3)); @@ -2446,7 +2445,7 @@ void nr_ulsch_qam64_qam64(c16_t *stream0_in, // Detection for 6th bit xmm0 = max_epi16_256(bit_met_s[0],bit_met_s[8],bit_met_s[16],bit_met_s[24],bit_met_s[32],bit_met_s[40],bit_met_s[48],bit_met_s[56]); - xmm1 = max_epi16_256(bit_met_s[3],bit_met_s[11],bit_met_s[19],bit_met_s[27],bit_met_s[35],bit_met_s[43],bit_met_s[51],bit_met_s[51]); + xmm1 = max_epi16_256(bit_met_s[3],bit_met_s[11],bit_met_s[19],bit_met_s[27],bit_met_s[35],bit_met_s[43],bit_met_s[51],bit_met_s[59]); xmm2 = max_epi16_256(bit_met_s[4],bit_met_s[12],bit_met_s[20],bit_met_s[28],bit_met_s[36],bit_met_s[44],bit_met_s[52],bit_met_s[60]); xmm3 = max_epi16_256(bit_met_s[7],bit_met_s[15],bit_met_s[23],bit_met_s[31],bit_met_s[39],bit_met_s[47],bit_met_s[55],bit_met_s[63]); logmax_den_re0 = simde_mm256_max_epi16(simde_mm256_max_epi16(xmm0, xmm1), simde_mm256_max_epi16(xmm2, xmm3)); From cdcb40353898a81015a441dc4204aef51b8f0772 Mon Sep 17 00:00:00 2001 From: Quency Lin Date: Tue, 3 Oct 2023 15:57:17 +0200 Subject: [PATCH 24/47] Refactor: Caculate bit_met_s[0..63] in for-loop --- .../NR_TRANSPORT/nr_ulsch_llr_computation.c | 485 ++---------------- 1 file changed, 47 insertions(+), 438 deletions(-) diff --git a/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c b/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c index f2796b35ce..61313efbdc 100644 --- a/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c +++ b/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c @@ -1414,15 +1414,6 @@ void nr_ulsch_qam64_qam64(c16_t *stream0_in, simde__m128i ch_mag_des; simde__m128i ch_mag_int; - simde__m128i ch_mag_98_over_42_with_sigma2; - simde__m128i ch_mag_74_over_42_with_sigma2; - simde__m128i ch_mag_58_over_42_with_sigma2; - simde__m128i ch_mag_50_over_42_with_sigma2; - simde__m128i ch_mag_34_over_42_with_sigma2; - simde__m128i ch_mag_18_over_42_with_sigma2; - simde__m128i ch_mag_26_over_42_with_sigma2; - simde__m128i ch_mag_10_over_42_with_sigma2; - simde__m128i ch_mag_2_over_42_with_sigma2; simde__m128i y0r_one_over_sqrt_21; simde__m128i y0r_three_over_sqrt_21; simde__m128i y0r_five_over_sqrt_21; @@ -1593,229 +1584,43 @@ void nr_ulsch_qam64_qam64(c16_t *stream0_in, } // Computing different multiples of ||h0||^2 + simde__m128i ch_mag_with_sigma2[10]; + enum ch_mag_over_42with_sigma2_vals {mag2=0, mag10, mag26, mag18, mag34, mag58, mag50, mag74, mag98}; // x=1, y=1 - ch_mag_2_over_42_with_sigma2 = simde_mm_mulhi_epi16(ch_mag_des, ONE_OVER_FOUR_SQRT_42); - ch_mag_2_over_42_with_sigma2 = simde_mm_slli_epi16(ch_mag_2_over_42_with_sigma2, 1); + ch_mag_with_sigma2[mag2] = simde_mm_slli_epi16(simde_mm_mulhi_epi16(ch_mag_des, ONE_OVER_FOUR_SQRT_42), 1); // x=1, y=3 - ch_mag_10_over_42_with_sigma2 = simde_mm_mulhi_epi16(ch_mag_des, FIVE_OVER_FOUR_SQRT_42); - ch_mag_10_over_42_with_sigma2 = simde_mm_slli_epi16(ch_mag_10_over_42_with_sigma2, 1); + ch_mag_with_sigma2[mag10] = simde_mm_slli_epi16(simde_mm_mulhi_epi16(ch_mag_des, FIVE_OVER_FOUR_SQRT_42), 1); // x=1, x=5 - ch_mag_26_over_42_with_sigma2 = simde_mm_mulhi_epi16(ch_mag_des, THIRTEEN_OVER_FOUR_SQRT_42); - ch_mag_26_over_42_with_sigma2 = simde_mm_slli_epi16(ch_mag_26_over_42_with_sigma2, 1); + ch_mag_with_sigma2[mag26] = simde_mm_slli_epi16(simde_mm_mulhi_epi16(ch_mag_des, THIRTEEN_OVER_FOUR_SQRT_42), 1); // x=1, y=7 - ch_mag_50_over_42_with_sigma2 = simde_mm_mulhi_epi16(ch_mag_des, TWENTYFIVE_OVER_FOUR_SQRT_42); - ch_mag_50_over_42_with_sigma2 = simde_mm_slli_epi16(ch_mag_50_over_42_with_sigma2, 1); + ch_mag_with_sigma2[mag50] = simde_mm_slli_epi16(simde_mm_mulhi_epi16(ch_mag_des, TWENTYFIVE_OVER_FOUR_SQRT_42), 1); // x=3, y=3 - ch_mag_18_over_42_with_sigma2 = simde_mm_mulhi_epi16(ch_mag_des, NINE_OVER_FOUR_SQRT_42); - ch_mag_18_over_42_with_sigma2 = simde_mm_slli_epi16(ch_mag_18_over_42_with_sigma2, 1); + ch_mag_with_sigma2[mag18] = simde_mm_slli_epi16(simde_mm_mulhi_epi16(ch_mag_des, NINE_OVER_FOUR_SQRT_42), 1); // x=3, y=5 - ch_mag_34_over_42_with_sigma2 = simde_mm_mulhi_epi16(ch_mag_des, SEVENTEEN_OVER_FOUR_SQRT_42); - ch_mag_34_over_42_with_sigma2 = simde_mm_slli_epi16(ch_mag_34_over_42_with_sigma2, 1); + ch_mag_with_sigma2[mag34] = simde_mm_slli_epi16(simde_mm_mulhi_epi16(ch_mag_des, SEVENTEEN_OVER_FOUR_SQRT_42), 1); // x=3, y=7 - ch_mag_58_over_42_with_sigma2 = simde_mm_mulhi_epi16(ch_mag_des, TWENTYNINE_OVER_FOUR_SQRT_42); - ch_mag_58_over_42_with_sigma2 = simde_mm_slli_epi16(ch_mag_58_over_42_with_sigma2, 2); + ch_mag_with_sigma2[mag58] = simde_mm_slli_epi16(simde_mm_mulhi_epi16(ch_mag_des, TWENTYNINE_OVER_FOUR_SQRT_42), 2); // x=5, y=5 - ch_mag_50_over_42_with_sigma2 = simde_mm_mulhi_epi16(ch_mag_des, TWENTYFIVE_OVER_FOUR_SQRT_42); - ch_mag_50_over_42_with_sigma2 = simde_mm_slli_epi16(ch_mag_50_over_42_with_sigma2, 1); + ch_mag_with_sigma2[mag50] = simde_mm_slli_epi16(simde_mm_mulhi_epi16(ch_mag_des, TWENTYFIVE_OVER_FOUR_SQRT_42), 1); // x=5, y=7 - ch_mag_74_over_42_with_sigma2 = simde_mm_mulhi_epi16(ch_mag_des, THIRTYSEVEN_OVER_FOUR_SQRT_42); - ch_mag_74_over_42_with_sigma2 = simde_mm_slli_epi16(ch_mag_74_over_42_with_sigma2, 2); + ch_mag_with_sigma2[mag74] = simde_mm_slli_epi16(simde_mm_mulhi_epi16(ch_mag_des, THIRTYSEVEN_OVER_FOUR_SQRT_42), 2); // x=7, y=7 - ch_mag_98_over_42_with_sigma2 = simde_mm_mulhi_epi16(ch_mag_des, FORTYNINE_OVER_FOUR_SQRT_42); - ch_mag_98_over_42_with_sigma2 = simde_mm_slli_epi16(ch_mag_98_over_42_with_sigma2, 2); + ch_mag_with_sigma2[mag98] = simde_mm_slli_epi16(simde_mm_mulhi_epi16(ch_mag_des, FORTYNINE_OVER_FOUR_SQRT_42), 2); // Computing Metrics simde__m128i bit_met_s[64]; - xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[0], a_sq_s[0]), y0_s[0]); - bit_met_s[0] = simde_mm_subs_epi16(xmm1, ch_mag_98_over_42_with_sigma2); + const enum ch_mag_over_42with_sigma2_vals table[] = { + mag98, mag74, mag58, mag50, mag50, mag58, mag74, mag98, mag74, mag50, mag34, mag26, mag26, mag34, mag50, mag74, + mag58, mag34, mag18, mag10, mag10, mag18, mag34, mag58, mag50, mag26, mag10, mag2, mag2, mag10, mag26, mag50}; - xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[1], a_sq_s[1]), y0_s[1]); - bit_met_s[1] = simde_mm_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); - - xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[2], a_sq_s[2]), y0_s[2]); - bit_met_s[2] = simde_mm_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); - - xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[3], a_sq_s[3]), y0_s[3]); - bit_met_s[3] = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - - xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[4], a_sq_s[4]), y0_s[4]); - bit_met_s[4] = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - - xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[5], a_sq_s[5]), y0_s[5]); - bit_met_s[5] = simde_mm_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); - - xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[6], a_sq_s[6]), y0_s[6]); - bit_met_s[6] = simde_mm_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); - - xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[7], a_sq_s[7]), y0_s[7]); - bit_met_s[7] = simde_mm_subs_epi16(xmm1, ch_mag_98_over_42_with_sigma2); - - xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[8], a_sq_s[8]), y0_s[8]); - bit_met_s[8] = simde_mm_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); - - xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[9], a_sq_s[9]), y0_s[9]); - bit_met_s[9] = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - - xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[10], a_sq_s[10]), y0_s[10]); - bit_met_s[10] = simde_mm_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); - - xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[11], a_sq_s[11]), y0_s[11]); - bit_met_s[11] = simde_mm_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); - - xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[12], a_sq_s[12]), y0_s[12]); - bit_met_s[12] = simde_mm_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); - - xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[13], a_sq_s[13]), y0_s[13]); - bit_met_s[13] = simde_mm_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); - - xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[14], a_sq_s[14]), y0_s[14]); - bit_met_s[14] = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - - xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[15], a_sq_s[15]), y0_s[15]); - bit_met_s[15] = simde_mm_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); - - xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[16], a_sq_s[16]), y0_s[16]); - bit_met_s[16] = simde_mm_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); - - xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[17], a_sq_s[17]), y0_s[17]); - bit_met_s[17] = simde_mm_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); - - xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[18], a_sq_s[18]), y0_s[18]); - bit_met_s[18] = simde_mm_subs_epi16(xmm1, ch_mag_18_over_42_with_sigma2); - - xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[19], a_sq_s[19]), y0_s[19]); - bit_met_s[19] = simde_mm_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); - - xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[20], a_sq_s[20]), y0_s[20]); - bit_met_s[20] = simde_mm_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); - - xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[21], a_sq_s[21]), y0_s[21]); - bit_met_s[21] = simde_mm_subs_epi16(xmm1, ch_mag_18_over_42_with_sigma2); - - xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[22], a_sq_s[22]), y0_s[22]); - bit_met_s[22] = simde_mm_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); - - xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[23], a_sq_s[23]), y0_s[23]); - bit_met_s[23] = simde_mm_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); - - xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[24], a_sq_s[24]), y0_s[24]); - bit_met_s[24] = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - - xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[25], a_sq_s[25]), y0_s[25]); - bit_met_s[25] = simde_mm_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); - - xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[26], a_sq_s[26]), y0_s[26]); - bit_met_s[26] = simde_mm_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); - - xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[27], a_sq_s[27]), y0_s[27]); - bit_met_s[27] = simde_mm_subs_epi16(xmm1, ch_mag_2_over_42_with_sigma2); - - xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[28], a_sq_s[28]), y0_s[28]); - bit_met_s[28] = simde_mm_subs_epi16(xmm1, ch_mag_2_over_42_with_sigma2); - - xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[29], a_sq_s[29]), y0_s[29]); - bit_met_s[29] = simde_mm_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); - - xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[30], a_sq_s[30]), y0_s[30]); - bit_met_s[30] = simde_mm_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); - - xmm1 = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[31], a_sq_s[31]), y0_s[31]); - bit_met_s[31] = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[32], a_sq_s[32]), y0_s[31]); - bit_met_s[32] = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - - xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[33], a_sq_s[33]), y0_s[30]); - bit_met_s[33] = simde_mm_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); - - xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[34], a_sq_s[34]), y0_s[29]); - bit_met_s[34] = simde_mm_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); - - xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[35], a_sq_s[35]), y0_s[28]); - bit_met_s[35] = simde_mm_subs_epi16(xmm1, ch_mag_2_over_42_with_sigma2); - - xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[36], a_sq_s[36]), y0_s[27]); - bit_met_s[36] = simde_mm_subs_epi16(xmm1, ch_mag_2_over_42_with_sigma2); - - xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[37], a_sq_s[37]), y0_s[26]); - bit_met_s[37] = simde_mm_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); - - xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[38], a_sq_s[38]), y0_s[25]); - bit_met_s[38] = simde_mm_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); - - xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[39], a_sq_s[39]), y0_s[24]); - bit_met_s[39] = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - - xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[40], a_sq_s[40]), y0_s[23]); - bit_met_s[40] = simde_mm_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); - - xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[41], a_sq_s[41]), y0_s[22]); - bit_met_s[41] = simde_mm_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); - - xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[42], a_sq_s[42]), y0_s[21]); - bit_met_s[42] = simde_mm_subs_epi16(xmm1, ch_mag_18_over_42_with_sigma2); - - xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[43], a_sq_s[43]), y0_s[20]); - bit_met_s[43] = simde_mm_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); - - xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[44], a_sq_s[44]), y0_s[19]); - bit_met_s[44] = simde_mm_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); - - xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[45], a_sq_s[45]), y0_s[18]); - bit_met_s[45] = simde_mm_subs_epi16(xmm1, ch_mag_18_over_42_with_sigma2); - - xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[46], a_sq_s[46]), y0_s[17]); - bit_met_s[46] = simde_mm_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); - - xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[47], a_sq_s[47]), y0_s[16]); - bit_met_s[47] = simde_mm_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); - - xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[48], a_sq_s[48]), y0_s[15]); - bit_met_s[48] = simde_mm_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); - - xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[49], a_sq_s[49]), y0_s[14]); - bit_met_s[49] = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - - xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[50], a_sq_s[50]), y0_s[13]); - bit_met_s[50] = simde_mm_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); - - xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[51], a_sq_s[51]), y0_s[12]); - bit_met_s[51] = simde_mm_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); - - xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[52], a_sq_s[52]), y0_s[11]); - bit_met_s[52] = simde_mm_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); - - xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[53], a_sq_s[53]), y0_s[10]); - bit_met_s[53] = simde_mm_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); - - xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[54], a_sq_s[54]), y0_s[9]); - bit_met_s[54] = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - - xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[55], a_sq_s[55]), y0_s[8]); - bit_met_s[55] = simde_mm_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); - - xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[56], a_sq_s[56]), y0_s[7]); - bit_met_s[56] = simde_mm_subs_epi16(xmm1, ch_mag_98_over_42_with_sigma2); - - xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[57], a_sq_s[57]), y0_s[6]); - bit_met_s[57] = simde_mm_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); - - xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[58], a_sq_s[58]), y0_s[5]); - bit_met_s[58] = simde_mm_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); - - xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[59], a_sq_s[59]), y0_s[4]); - bit_met_s[59] = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - - xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[60], a_sq_s[60]), y0_s[3]); - bit_met_s[60] = simde_mm_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - - xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[61], a_sq_s[61]), y0_s[2]); - bit_met_s[61] = simde_mm_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); - - xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[62], a_sq_s[62]), y0_s[1]); - bit_met_s[62] = simde_mm_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); - - xmm1 = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[63], a_sq_s[63]), y0_s[0]); - bit_met_s[63] = simde_mm_subs_epi16(xmm1, ch_mag_98_over_42_with_sigma2); + for(int i=0; i<32; i++){ + const simde__m128i x = simde_mm_adds_epi16(simde_mm_subs_epi16(psi_a_s[i], a_sq_s[i]), y0_s[i]); + bit_met_s[i] = simde_mm_subs_epi16(x, ch_mag_with_sigma2[table[i]]); + } + for(int i=0; i<32; i++){ + const simde__m128i x = simde_mm_subs_epi16(simde_mm_subs_epi16(psi_a_s[32 + i], a_sq_s[32 + i]), y0_s[31 - i]); + bit_met_s[32 + i] = simde_mm_subs_epi16(x, ch_mag_with_sigma2[table[31 - i]]); + } // Detection for bits simde__m128i logmax_den_re0; @@ -1955,15 +1760,6 @@ void nr_ulsch_qam64_qam64(c16_t *stream0_in, simde__m256i ch_mag_des; simde__m256i ch_mag_int; - simde__m256i ch_mag_98_over_42_with_sigma2; - simde__m256i ch_mag_74_over_42_with_sigma2; - simde__m256i ch_mag_58_over_42_with_sigma2; - simde__m256i ch_mag_50_over_42_with_sigma2; - simde__m256i ch_mag_34_over_42_with_sigma2; - simde__m256i ch_mag_18_over_42_with_sigma2; - simde__m256i ch_mag_26_over_42_with_sigma2; - simde__m256i ch_mag_10_over_42_with_sigma2; - simde__m256i ch_mag_2_over_42_with_sigma2; simde__m256i y0r_one_over_sqrt_21; simde__m256i y0r_three_over_sqrt_21; simde__m256i y0r_five_over_sqrt_21; @@ -2136,230 +1932,43 @@ void nr_ulsch_qam64_qam64(c16_t *stream0_in, } // Computing different multiples of ||h0||^2 - // x=1, y=1 - ch_mag_2_over_42_with_sigma2 = simde_mm256_mulhi_epi16(ch_mag_des, ONE_OVER_FOUR_SQRT_42); - ch_mag_2_over_42_with_sigma2 = simde_mm256_slli_epi16(ch_mag_2_over_42_with_sigma2, 1); + simde__m256i ch_mag_with_sigma2[10]; + enum ch_mag_over_42with_sigma2_vals {mag2=0, mag10, mag26, mag18, mag34, mag58, mag50, mag74, mag98}; + // x=1, y=1 + ch_mag_with_sigma2[mag2] = simde_mm256_slli_epi16(simde_mm256_mulhi_epi16(ch_mag_des, ONE_OVER_FOUR_SQRT_42), 1); // x=1, y=3 - ch_mag_10_over_42_with_sigma2 = simde_mm256_mulhi_epi16(ch_mag_des, FIVE_OVER_FOUR_SQRT_42); - ch_mag_10_over_42_with_sigma2 = simde_mm256_slli_epi16(ch_mag_10_over_42_with_sigma2, 1); + ch_mag_with_sigma2[mag10] = simde_mm256_slli_epi16(simde_mm256_mulhi_epi16(ch_mag_des, FIVE_OVER_FOUR_SQRT_42), 1); // x=1, x=5 - ch_mag_26_over_42_with_sigma2 = simde_mm256_mulhi_epi16(ch_mag_des, THIRTEEN_OVER_FOUR_SQRT_42); - ch_mag_26_over_42_with_sigma2 = simde_mm256_slli_epi16(ch_mag_26_over_42_with_sigma2, 1); + ch_mag_with_sigma2[mag26] = simde_mm256_slli_epi16(simde_mm256_mulhi_epi16(ch_mag_des, THIRTEEN_OVER_FOUR_SQRT_42), 1); // x=1, y=7 - ch_mag_50_over_42_with_sigma2 = simde_mm256_mulhi_epi16(ch_mag_des, TWENTYFIVE_OVER_FOUR_SQRT_42); - ch_mag_50_over_42_with_sigma2 = simde_mm256_slli_epi16(ch_mag_50_over_42_with_sigma2, 1); + ch_mag_with_sigma2[mag50] = simde_mm256_slli_epi16(simde_mm256_mulhi_epi16(ch_mag_des, TWENTYFIVE_OVER_FOUR_SQRT_42), 1); // x=3, y=3 - ch_mag_18_over_42_with_sigma2 = simde_mm256_mulhi_epi16(ch_mag_des, NINE_OVER_FOUR_SQRT_42); - ch_mag_18_over_42_with_sigma2 = simde_mm256_slli_epi16(ch_mag_18_over_42_with_sigma2, 1); + ch_mag_with_sigma2[mag18] = simde_mm256_slli_epi16(simde_mm256_mulhi_epi16(ch_mag_des, NINE_OVER_FOUR_SQRT_42), 1); // x=3, y=5 - ch_mag_34_over_42_with_sigma2 = simde_mm256_mulhi_epi16(ch_mag_des, SEVENTEEN_OVER_FOUR_SQRT_42); - ch_mag_34_over_42_with_sigma2 = simde_mm256_slli_epi16(ch_mag_34_over_42_with_sigma2, 1); + ch_mag_with_sigma2[mag34] = simde_mm256_slli_epi16(simde_mm256_mulhi_epi16(ch_mag_des, SEVENTEEN_OVER_FOUR_SQRT_42), 1); // x=3, y=7 - ch_mag_58_over_42_with_sigma2 = simde_mm256_mulhi_epi16(ch_mag_des, TWENTYNINE_OVER_FOUR_SQRT_42); - ch_mag_58_over_42_with_sigma2 = simde_mm256_slli_epi16(ch_mag_58_over_42_with_sigma2, 2); + ch_mag_with_sigma2[mag58] = simde_mm256_slli_epi16(simde_mm256_mulhi_epi16(ch_mag_des, TWENTYNINE_OVER_FOUR_SQRT_42), 2); // x=5, y=5 - ch_mag_50_over_42_with_sigma2 = simde_mm256_mulhi_epi16(ch_mag_des, TWENTYFIVE_OVER_FOUR_SQRT_42); - ch_mag_50_over_42_with_sigma2 = simde_mm256_slli_epi16(ch_mag_50_over_42_with_sigma2, 1); + ch_mag_with_sigma2[mag50] = simde_mm256_slli_epi16(simde_mm256_mulhi_epi16(ch_mag_des, TWENTYFIVE_OVER_FOUR_SQRT_42), 1); // x=5, y=7 - ch_mag_74_over_42_with_sigma2 = simde_mm256_mulhi_epi16(ch_mag_des, THIRTYSEVEN_OVER_FOUR_SQRT_42); - ch_mag_74_over_42_with_sigma2 = simde_mm256_slli_epi16(ch_mag_74_over_42_with_sigma2, 2); + ch_mag_with_sigma2[mag74] = simde_mm256_slli_epi16(simde_mm256_mulhi_epi16(ch_mag_des, THIRTYSEVEN_OVER_FOUR_SQRT_42), 2); // x=7, y=7 - ch_mag_98_over_42_with_sigma2 = simde_mm256_mulhi_epi16(ch_mag_des, FORTYNINE_OVER_FOUR_SQRT_42); - ch_mag_98_over_42_with_sigma2 = simde_mm256_slli_epi16(ch_mag_98_over_42_with_sigma2, 2); + ch_mag_with_sigma2[mag98] = simde_mm256_slli_epi16(simde_mm256_mulhi_epi16(ch_mag_des, FORTYNINE_OVER_FOUR_SQRT_42), 2); // Computing Metrics simde__m256i bit_met_s[64]; + const enum ch_mag_over_42with_sigma2_vals table[] = { + mag98, mag74, mag58, mag50, mag50, mag58, mag74, mag98, mag74, mag50, mag34, mag26, mag26, mag34, mag50, mag74, + mag58, mag34, mag18, mag10, mag10, mag18, mag34, mag58, mag50, mag26, mag10, mag2, mag2, mag10, mag26, mag50}; - xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[0], a_sq_s[0]), y0_s[0]); - bit_met_s[0] = simde_mm256_subs_epi16(xmm1, ch_mag_98_over_42_with_sigma2); - - xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[1], a_sq_s[1]), y0_s[1]); - bit_met_s[1] = simde_mm256_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); - - xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[2], a_sq_s[2]), y0_s[2]); - bit_met_s[2] = simde_mm256_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); - - xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[3], a_sq_s[3]), y0_s[3]); - bit_met_s[3] = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - - xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[4], a_sq_s[4]), y0_s[4]); - bit_met_s[4] = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - - xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[5], a_sq_s[5]), y0_s[5]); - bit_met_s[5] = simde_mm256_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); - - xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[6], a_sq_s[6]), y0_s[6]); - bit_met_s[6] = simde_mm256_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); - - xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[7], a_sq_s[7]), y0_s[7]); - bit_met_s[7] = simde_mm256_subs_epi16(xmm1, ch_mag_98_over_42_with_sigma2); - - xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[8], a_sq_s[8]), y0_s[8]); - bit_met_s[8] = simde_mm256_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); - - xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[9], a_sq_s[9]), y0_s[9]); - bit_met_s[9] = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - - xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[10], a_sq_s[10]), y0_s[10]); - bit_met_s[10] = simde_mm256_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); - - xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[11], a_sq_s[11]), y0_s[11]); - bit_met_s[11] = simde_mm256_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); - - xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[12], a_sq_s[12]), y0_s[12]); - bit_met_s[12] = simde_mm256_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); - - xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[13], a_sq_s[13]), y0_s[13]); - bit_met_s[13] = simde_mm256_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); - - xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[14], a_sq_s[14]), y0_s[14]); - bit_met_s[14] = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - - xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[15], a_sq_s[15]), y0_s[15]); - bit_met_s[15] = simde_mm256_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); - - xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[16], a_sq_s[16]), y0_s[16]); - bit_met_s[16] = simde_mm256_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); - - xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[17], a_sq_s[17]), y0_s[17]); - bit_met_s[17] = simde_mm256_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); - - xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[18], a_sq_s[18]), y0_s[18]); - bit_met_s[18] = simde_mm256_subs_epi16(xmm1, ch_mag_18_over_42_with_sigma2); - - xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[19], a_sq_s[19]), y0_s[19]); - bit_met_s[19] = simde_mm256_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); - - xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[20], a_sq_s[20]), y0_s[20]); - bit_met_s[20] = simde_mm256_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); - - xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[21], a_sq_s[21]), y0_s[21]); - bit_met_s[21] = simde_mm256_subs_epi16(xmm1, ch_mag_18_over_42_with_sigma2); - - xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[22], a_sq_s[22]), y0_s[22]); - bit_met_s[22] = simde_mm256_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); - - xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[23], a_sq_s[23]), y0_s[23]); - bit_met_s[23] = simde_mm256_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); - - xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[24], a_sq_s[24]), y0_s[24]); - bit_met_s[24] = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - - xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[25], a_sq_s[25]), y0_s[25]); - bit_met_s[25] = simde_mm256_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); - - xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[26], a_sq_s[26]), y0_s[26]); - bit_met_s[26] = simde_mm256_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); - - xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[27], a_sq_s[27]), y0_s[27]); - bit_met_s[27] = simde_mm256_subs_epi16(xmm1, ch_mag_2_over_42_with_sigma2); - - xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[28], a_sq_s[28]), y0_s[28]); - bit_met_s[28] = simde_mm256_subs_epi16(xmm1, ch_mag_2_over_42_with_sigma2); - - xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[29], a_sq_s[29]), y0_s[29]); - bit_met_s[29] = simde_mm256_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); - - xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[30], a_sq_s[30]), y0_s[30]); - bit_met_s[30] = simde_mm256_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); - - xmm1 = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[31], a_sq_s[31]), y0_s[31]); - bit_met_s[31] = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[32], a_sq_s[32]), y0_s[31]); - bit_met_s[32] = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - - xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[33], a_sq_s[33]), y0_s[30]); - bit_met_s[33] = simde_mm256_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); - - xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[34], a_sq_s[34]), y0_s[29]); - bit_met_s[34] = simde_mm256_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); - - xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[35], a_sq_s[35]), y0_s[28]); - bit_met_s[35] = simde_mm256_subs_epi16(xmm1, ch_mag_2_over_42_with_sigma2); - - xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[36], a_sq_s[36]), y0_s[27]); - bit_met_s[36] = simde_mm256_subs_epi16(xmm1, ch_mag_2_over_42_with_sigma2); - - xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[37], a_sq_s[37]), y0_s[26]); - bit_met_s[37] = simde_mm256_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); - - xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[38], a_sq_s[38]), y0_s[25]); - bit_met_s[38] = simde_mm256_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); - - xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[39], a_sq_s[39]), y0_s[24]); - bit_met_s[39] = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - - xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[40], a_sq_s[40]), y0_s[23]); - bit_met_s[40] = simde_mm256_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); - - xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[41], a_sq_s[41]), y0_s[22]); - bit_met_s[41] = simde_mm256_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); - - xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[42], a_sq_s[42]), y0_s[21]); - bit_met_s[42] = simde_mm256_subs_epi16(xmm1, ch_mag_18_over_42_with_sigma2); - - xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[43], a_sq_s[43]), y0_s[20]); - bit_met_s[43] = simde_mm256_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); - - xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[44], a_sq_s[44]), y0_s[19]); - bit_met_s[44] = simde_mm256_subs_epi16(xmm1, ch_mag_10_over_42_with_sigma2); - - xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[45], a_sq_s[45]), y0_s[18]); - bit_met_s[45] = simde_mm256_subs_epi16(xmm1, ch_mag_18_over_42_with_sigma2); - - xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[46], a_sq_s[46]), y0_s[17]); - bit_met_s[46] = simde_mm256_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); - - xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[47], a_sq_s[47]), y0_s[16]); - bit_met_s[47] = simde_mm256_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); - - xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[48], a_sq_s[48]), y0_s[15]); - bit_met_s[48] = simde_mm256_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); - - xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[49], a_sq_s[49]), y0_s[14]); - bit_met_s[49] = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - - xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[50], a_sq_s[50]), y0_s[13]); - bit_met_s[50] = simde_mm256_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); - - xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[51], a_sq_s[51]), y0_s[12]); - bit_met_s[51] = simde_mm256_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); - - xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[52], a_sq_s[52]), y0_s[11]); - bit_met_s[52] = simde_mm256_subs_epi16(xmm1, ch_mag_26_over_42_with_sigma2); - - xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[53], a_sq_s[53]), y0_s[10]); - bit_met_s[53] = simde_mm256_subs_epi16(xmm1, ch_mag_34_over_42_with_sigma2); - - xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[54], a_sq_s[54]), y0_s[9]); - bit_met_s[54] = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - - xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[55], a_sq_s[55]), y0_s[8]); - bit_met_s[55] = simde_mm256_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); - - xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[56], a_sq_s[56]), y0_s[7]); - bit_met_s[56] = simde_mm256_subs_epi16(xmm1, ch_mag_98_over_42_with_sigma2); - - xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[57], a_sq_s[57]), y0_s[6]); - bit_met_s[57] = simde_mm256_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); - - xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[58], a_sq_s[58]), y0_s[5]); - bit_met_s[58] = simde_mm256_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); - - xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[59], a_sq_s[59]), y0_s[4]); - bit_met_s[59] = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - - xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[60], a_sq_s[60]), y0_s[3]); - bit_met_s[60] = simde_mm256_subs_epi16(xmm1, ch_mag_50_over_42_with_sigma2); - - xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[61], a_sq_s[61]), y0_s[2]); - bit_met_s[61] = simde_mm256_subs_epi16(xmm1, ch_mag_58_over_42_with_sigma2); - - xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[62], a_sq_s[62]), y0_s[1]); - bit_met_s[62] = simde_mm256_subs_epi16(xmm1, ch_mag_74_over_42_with_sigma2); - - xmm1 = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[63], a_sq_s[63]), y0_s[0]); - bit_met_s[63] = simde_mm256_subs_epi16(xmm1, ch_mag_98_over_42_with_sigma2); + for(int i=0; i<32; i++){ + const simde__m256i x = simde_mm256_adds_epi16(simde_mm256_subs_epi16(psi_a_s[i], a_sq_s[i]), y0_s[i]); + bit_met_s[i] = simde_mm256_subs_epi16(x, ch_mag_with_sigma2[table[i]]); + } + for(int i=0; i<32; i++){ + const simde__m256i x = simde_mm256_subs_epi16(simde_mm256_subs_epi16(psi_a_s[32 + i], a_sq_s[32 + i]), y0_s[31 - i]); + bit_met_s[32 + i] = simde_mm256_subs_epi16(x, ch_mag_with_sigma2[table[31 - i]]); + } // Detection for bits simde__m256i logmax_den_re0; From e92c827820662e02ff0ffa6cc387062f73faf826 Mon Sep 17 00:00:00 2001 From: Quency Lin Date: Tue, 3 Oct 2023 23:49:30 +0200 Subject: [PATCH 25/47] fix: SISO 128 SIMDe due to rebase to 2023.w39 --- .../NR_TRANSPORT/nr_ulsch_llr_computation.c | 29 +++++++------------ 1 file changed, 10 insertions(+), 19 deletions(-) diff --git a/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c b/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c index 61313efbdc..eb99669564 100644 --- a/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c +++ b/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c @@ -38,7 +38,7 @@ #ifdef __aarch64__ #define USE_128BIT #endif - +#define USE_128BIT //---------------------------------------------------------------------------------------------- // QPSK @@ -71,10 +71,8 @@ void nr_ulsch_16qam_llr(int32_t *rxdataF_comp, simde__m128i *ch_mag; simde__m128i *ulsch_llr_128 = (simde__m128i*) ulsch_llr; int i; - int nb_rb = nb_re / NR_NB_SC_PER_RB; - int off = ((nb_rb&1) == 1)? 4:0; - ch_mag = (simde__m128i*)&ul_ch_mag[(symbol*(off+(nb_rb*12)))]; + ch_mag = (simde__m128i*)ul_ch_mag; nb_re >>= 2; // length in quad words (4 REs) nb_re += ((nb_re&3) == 0 ? 0 : 1); @@ -129,14 +127,10 @@ void nr_ulsch_64qam_llr(int32_t *rxdataF_comp, uint8_t symbol) { #ifdef USE_128BIT - int nb_rb = nb_re / NR_NB_SC_PER_RB; - int off = ((nb_rb&1) == 1)? 4:0; - simde__m128i *rxF = (simde__m128i*)rxdataF_comp; - simde__m128i *ch_mag,*ch_magb; + simde__m128i *ch_mag = (simde__m128i*)ul_ch_mag; + simde__m128i *ch_magb = (simde__m128i*)ul_ch_magb; int i; - ch_mag = (simde__m128i*)&ul_ch_mag[(symbol*(off+(nb_rb*12)))]; - ch_magb = (simde__m128i*)&ul_ch_magb[(symbol*(off+(nb_rb*12)))]; nb_re = nb_re>>2; // length in 128-bit words (4 REs) nb_re += ((nb_re&3) == 0 ? 0 : 1); @@ -223,15 +217,12 @@ void nr_ulsch_256qam_llr(int32_t *rxdataF_comp, uint8_t symbol) { #ifdef USE_128BIT - int off = ((nb_rb&1) == 1)? 4:0; - simde__m128i *rxF = (simde__m128i*)rxdataF_comp; - simde__m128i *ch_mag,*ch_magb,*ch_magc; simde__m128i *llr128=(simde__m128i*)ulsch_llr; - ch_mag = (simde__m128i*)&ul_ch_mag[(symbol*(off+(nb_rb*12)))]; - ch_magb = (simde__m128i*)&ul_ch_magb[(symbol*(off+(nb_rb*12)))]; - ch_magc = (simde__m128i*)&ul_ch_magc[(symbol*(off+(nb_rb*12)))]; + simde__m128i* ch_mag = (simde__m128i*)ul_ch_mag; + simde__m128i* ch_magb = (simde__m128i*)ul_ch_magb; + simde__m128i* ch_magc = (simde__m128i*)ul_ch_magc; int len_mod4 = nb_re & 3; int nb_re128 = nb_re >> 2; // length in 128-bit words (4 REs) @@ -264,9 +255,9 @@ void nr_ulsch_256qam_llr(int32_t *rxdataF_comp, simde__m64 *llr64 = (simde__m64 *)llr128; simde__m64 xmm0,xmm1,xmm2; simde__m64 *rxF = (simde__m64*)rxdataF_comp; - simde__m64 *ch_mag = (simde__m64*)&ul_ch_mag[(symbol*(off+(nb_rb*12)))]; - simde__m64 *ch_magb = (simde__m64*)&ul_ch_magb[(symbol*(off+(nb_rb*12)))]; - simde__m64 *ch_magc = (simde__m64*)&ul_ch_magc[(symbol*(off+(nb_rb*12)))]; + simde__m64 *ch_mag = (simde__m64*)ul_ch_mag; + simde__m64 *ch_magb = (simde__m64*)ul_ch_magb; + simde__m64 *ch_magc = (simde__m64*)ul_ch_magc; xmm0 = simde_mm_abs_pi16(rxF[last_2_re]); // registers of even index in xmm0-> |y_R|, registers of odd index in xmm0-> |y_I| xmm0 = simde_mm_subs_pi16(ch_mag[last_2_re],xmm0); // registers of even index in xmm0-> |y_R|-|h|^2, registers of odd index in xmm0-> |y_I|-|h|^2 From 169a9be8cd5aeae8dfb288fd987cc33934a0c8de Mon Sep 17 00:00:00 2001 From: rmagueta Date: Thu, 28 Sep 2023 11:54:04 +0100 Subject: [PATCH 26/47] Fix Msg3 MAC CE C-RNTI Reset Msg4_ACKed to not schedule ULSCH and DLSCH before RRC Reconfiguration --- openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_RA.c | 4 +--- openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_uci.c | 2 ++ openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_ulsch.c | 3 +++ 3 files changed, 6 insertions(+), 3 deletions(-) diff --git a/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_RA.c b/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_RA.c index 71dd7731e5..f4caa05fdb 100644 --- a/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_RA.c +++ b/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_RA.c @@ -1879,16 +1879,14 @@ static void nr_check_Msg4_Ack(module_id_t module_id, int CC_id, frame_t frame, s NR_UE_sched_ctrl_t *sched_ctrl = &UE->UE_sched_ctrl; NR_UE_harq_t *harq = &sched_ctrl->harq_processes[current_harq_pid]; - NR_mac_stats_t *stats = &UE->mac_stats; LOG_D(NR_MAC, "ue rnti 0x%04x, harq is waiting %d, round %d, frame %d %d, harq id %d\n", ra->rnti, harq->is_waiting, harq->round, frame, slot, current_harq_pid); if (harq->is_waiting == 0) { if (harq->round == 0) { - if (stats->dl.errors == 0) { + if (UE->Msg4_ACKed) { LOG_A(NR_MAC, "(UE RNTI 0x%04x) Received Ack of RA-Msg4. CBRA procedure succeeded!\n", ra->rnti); - UE->Msg4_ACKed = true; UE->ra_timer = 0; // Pause scheduling according to: diff --git a/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_uci.c b/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_uci.c index 77b0eeba9e..30d06ef2a8 100644 --- a/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_uci.c +++ b/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_uci.c @@ -1011,6 +1011,8 @@ void handle_nr_uci_pucch_0_1(module_id_t mod_id, remove_front_nr_list(&sched_ctrl->feedback_dl_harq); LOG_D(NR_MAC,"%4d.%2d bit %d pid %d ack/nack %d\n",frame, slot, harq_bit,pid,harq_value); handle_dl_harq(UE, pid, harq_value == 0 && harq_confidence == 0, nrmac->dl_bler.harq_round_max); + if (!UE->Msg4_ACKed && harq_value == 0 && harq_confidence == 0) + UE->Msg4_ACKed = true; if (harq_confidence == 1) UE->mac_stats.pucch0_DTX++; } diff --git a/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_ulsch.c b/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_ulsch.c index 174a50bead..507c16c9b9 100644 --- a/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_ulsch.c +++ b/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_ulsch.c @@ -795,6 +795,9 @@ static void _nr_rx_sdu(const module_id_t gnb_mod_idP, LOG_W(NR_MAC, "No UE found with C-RNTI %04x, ignoring Msg.3 to have UE come back with new RA attempt\n", ra->rnti); return; } else { + // Reset Msg4_ACKed to not schedule ULSCH and DLSCH before RRC Reconfiguration + UE_C->Msg4_ACKed = false; + // The UE identified by C-RNTI still exists at the gNB nr_mac_reset_ul_failure(&UE_C->UE_sched_ctrl); From 832bea2482cb4465cd9cc9365d23d48ee57b29ef Mon Sep 17 00:00:00 2001 From: francescomani Date: Mon, 2 Oct 2023 18:59:24 +0200 Subject: [PATCH 27/47] implementing PDCP entity suspend --- openair2/LAYER2/nr_pdcp/nr_pdcp_entity.c | 19 ++++++++++++++++- openair2/LAYER2/nr_pdcp/nr_pdcp_entity.h | 1 + openair2/LAYER2/nr_pdcp/nr_pdcp_oai_api.c | 26 +++++++++++++++++++++++ openair2/LAYER2/nr_pdcp/nr_pdcp_oai_api.h | 2 ++ 4 files changed, 47 insertions(+), 1 deletion(-) diff --git a/openair2/LAYER2/nr_pdcp/nr_pdcp_entity.c b/openair2/LAYER2/nr_pdcp/nr_pdcp_entity.c index 453422f278..9dda9b9ace 100644 --- a/openair2/LAYER2/nr_pdcp/nr_pdcp_entity.c +++ b/openair2/LAYER2/nr_pdcp/nr_pdcp_entity.c @@ -369,7 +369,7 @@ void nr_pdcp_entity_set_time(struct nr_pdcp_entity_t *entity, uint64_t now) check_t_reordering(entity); } -void nr_pdcp_entity_release(nr_pdcp_entity_t *entity) +static void deliver_all_sdus(nr_pdcp_entity_t *entity) { // deliver the PDCP SDUs stored in the receiving PDCP entity to upper layers while (entity->rx_list != NULL) { @@ -384,6 +384,22 @@ void nr_pdcp_entity_release(nr_pdcp_entity_t *entity) } } +void nr_pdcp_entity_suspend(nr_pdcp_entity_t *entity) +{ + entity->tx_next = 0; + if (entity->t_reordering_start != 0) { + entity->t_reordering_start = 0; + deliver_all_sdus(entity); + } + entity->rx_next = 0; + entity->rx_deliv = 0; +} + +void nr_pdcp_entity_release(nr_pdcp_entity_t *entity) +{ + deliver_all_sdus(entity); +} + void nr_pdcp_entity_delete(nr_pdcp_entity_t *entity) { nr_pdcp_sdu_t *cur = entity->rx_list; @@ -444,6 +460,7 @@ nr_pdcp_entity_t *new_nr_pdcp_entity( ret->delete_entity = nr_pdcp_entity_delete; ret->release_entity = nr_pdcp_entity_release; + ret->suspend_entity = nr_pdcp_entity_suspend; ret->get_stats = nr_pdcp_entity_get_stats; ret->deliver_sdu = deliver_sdu; diff --git a/openair2/LAYER2/nr_pdcp/nr_pdcp_entity.h b/openair2/LAYER2/nr_pdcp/nr_pdcp_entity.h index 83d08ea259..078c32b6c0 100644 --- a/openair2/LAYER2/nr_pdcp/nr_pdcp_entity.h +++ b/openair2/LAYER2/nr_pdcp/nr_pdcp_entity.h @@ -77,6 +77,7 @@ typedef struct nr_pdcp_entity_t { int sdu_id, char *pdu_buffer, int pdu_max_size); void (*delete_entity)(struct nr_pdcp_entity_t *entity); void (*release_entity)(struct nr_pdcp_entity_t *entity); + void (*suspend_entity)(struct nr_pdcp_entity_t *entity); void (*get_stats)(struct nr_pdcp_entity_t *entity, nr_pdcp_statistics_t *out); /* set_security: pass -1 to integrity_algorithm / ciphering_algorithm diff --git a/openair2/LAYER2/nr_pdcp/nr_pdcp_oai_api.c b/openair2/LAYER2/nr_pdcp/nr_pdcp_oai_api.c index d5766a7814..21331ee607 100644 --- a/openair2/LAYER2/nr_pdcp/nr_pdcp_oai_api.c +++ b/openair2/LAYER2/nr_pdcp/nr_pdcp_oai_api.c @@ -1057,6 +1057,32 @@ bool nr_pdcp_data_req_srb(ue_id_t ue_id, return 1; } +void nr_pdcp_suspend_srb(ue_id_t ue_id, int srb_id) +{ + nr_pdcp_manager_lock(nr_pdcp_ue_manager); + nr_pdcp_ue_t *ue = nr_pdcp_manager_get_ue(nr_pdcp_ue_manager, ue_id); + nr_pdcp_entity_t *srb = ue->srb[srb_id - 1]; + if (srb == NULL) { + LOG_E(PDCP, "Trying to susbend SRB with ID %d but it is not established\n", srb_id); + return; + } + srb->suspend_entity(srb); + nr_pdcp_manager_unlock(nr_pdcp_ue_manager); +} + +void nr_pdcp_suspend_drb(ue_id_t ue_id, int drb_id) +{ + nr_pdcp_manager_lock(nr_pdcp_ue_manager); + nr_pdcp_ue_t *ue = nr_pdcp_manager_get_ue(nr_pdcp_ue_manager, ue_id); + nr_pdcp_entity_t *drb = ue->drb[drb_id - 1]; + if (drb == NULL) { + LOG_E(PDCP, "Trying to susbend DRB with ID %d but it is not established\n", drb_id); + return; + } + drb->suspend_entity(drb); + nr_pdcp_manager_unlock(nr_pdcp_ue_manager); +} + void nr_pdcp_reconfigure_srb(ue_id_t ue_id, int srb_id, long t_Reordering) { nr_pdcp_manager_lock(nr_pdcp_ue_manager); diff --git a/openair2/LAYER2/nr_pdcp/nr_pdcp_oai_api.h b/openair2/LAYER2/nr_pdcp/nr_pdcp_oai_api.h index 36568b58ba..6035e34bf4 100644 --- a/openair2/LAYER2/nr_pdcp/nr_pdcp_oai_api.h +++ b/openair2/LAYER2/nr_pdcp/nr_pdcp_oai_api.h @@ -66,6 +66,8 @@ void nr_DRB_preconfiguration(ue_id_t crntiMaybeUEid); bool nr_pdcp_remove_UE(ue_id_t ue_id); void nr_pdcp_reestablishment(ue_id_t ue_id); +void nr_pdcp_suspend_srb(ue_id_t ue_id, int srb_id); +void nr_pdcp_suspend_drb(ue_id_t ue_id, int drb_id); void nr_pdcp_reconfigure_srb(ue_id_t ue_id, int srb_id, long t_Reordering); void nr_pdcp_reconfigure_drb(ue_id_t ue_id, int drb_id, long t_Reordering); void nr_pdcp_release_srb(ue_id_t ue_id, int srb_id); From 12e09526e8b61e6dd9f874d42c329f0a2a8a2153 Mon Sep 17 00:00:00 2001 From: mir Date: Thu, 28 Sep 2023 10:41:32 +0200 Subject: [PATCH 28/47] E2AP Version 1,2,3 and KPM version 2, 3 --- CMakeLists.txt | 18 ++ executables/nr-softmodem.c | 8 +- openair2/E2AP/CMakeLists.txt | 32 +++ openair2/E2AP/RAN_FUNCTION/CMakeLists.txt | 5 + .../RAN_FUNCTION/CUSTOMIZED/CMakeLists.txt | 2 + .../RAN_FUNCTION/CUSTOMIZED/ran_func_gtp.c | 9 +- .../RAN_FUNCTION/CUSTOMIZED/ran_func_gtp.h | 4 - .../RAN_FUNCTION/CUSTOMIZED/ran_func_pdcp.c | 13 +- .../RAN_FUNCTION/CUSTOMIZED/ran_func_pdcp.h | 6 - .../RAN_FUNCTION/CUSTOMIZED/ran_func_rlc.c | 7 + .../RAN_FUNCTION/CUSTOMIZED/ran_func_rlc.h | 5 - .../E2AP/RAN_FUNCTION/O-RAN/CMakeLists.txt | 1 + .../E2AP/RAN_FUNCTION/O-RAN/ran_func_kpm.c | 203 +++++++++++------- .../E2AP/RAN_FUNCTION/O-RAN/ran_func_rc.c | 2 + openair2/E2AP/RAN_FUNCTION/init_ran_func.c | 6 + openair2/E2AP/RAN_FUNCTION/read_setup_ran.c | 42 ++++ openair2/E2AP/RAN_FUNCTION/read_setup_ran.h | 27 +++ openair2/E2AP/README.md | 24 ++- openair2/E2AP/flexric | 2 +- 19 files changed, 309 insertions(+), 107 deletions(-) create mode 100644 openair2/E2AP/RAN_FUNCTION/read_setup_ran.c create mode 100644 openair2/E2AP/RAN_FUNCTION/read_setup_ran.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 0b48680830..4c2baa4de3 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -289,6 +289,15 @@ add_definitions(-DHAVE_NETINET_IN_H) set(E2_AGENT "OFF" CACHE STRING "O-RAN-compliant E2 Agent") set_property(CACHE E2_AGENT PROPERTY STRINGS "ON" "OFF") +set(E2AP_VERSION "E2AP_V2" CACHE STRING "E2AP version") +set_property(CACHE E2AP_VERSION PROPERTY STRINGS "E2AP_V1" "E2AP_V2" "E2AP_V3") +message(STATUS "Selected E2AP_VERSION: ${E2AP_VERSION}") + +set(KPM_VERSION "KPM_V2" CACHE STRING "The KPM SM version to use") +set_property(CACHE KPM_VERSION PROPERTY STRINGS "KPM_V2" "KPM_V3") +message(STATUS "Selected KPM Version: ${KPM_VERSION}") + + ################################################## # ASN.1 grammar C code generation & dependencies # ################################################## @@ -1409,9 +1418,11 @@ add_library(L2 ) target_link_libraries(L2 PRIVATE x2ap s1ap lte_rrc m2ap) target_link_libraries(L2 PRIVATE asn1_lte_rrc_hdrs asn1_nr_rrc_hdrs) + if(E2_AGENT) target_link_libraries(L2 PUBLIC e2_agent e2_ran_func) target_compile_definitions(L2 PRIVATE E2_AGENT) + target_compile_definitions(L2 PRIVATE ${E2AP_VERSION} ${KPM_VERSION}) endif() @@ -1443,6 +1454,7 @@ target_link_libraries(e1_pdcp_if PRIVATE asn1_nr_rrc_hdrs asn1_lte_rrc_hdrs) target_link_libraries(L2_NR PRIVATE f1ap x2ap s1ap ngap nr_rrc e1ap nr_rlc) if(E2_AGENT) target_link_libraries(L2_NR PUBLIC e2_agent e2_ran_func) + target_compile_definitions(L2_NR PRIVATE ${E2AP_VERSION} ${KPM_VERSION}) target_compile_definitions(L2_NR PRIVATE E2_AGENT) endif() @@ -1965,6 +1977,7 @@ target_link_libraries(lte-softmodem PRIVATE asn1_nr_rrc_hdrs asn1_lte_rrc_hdrs) if(E2_AGENT) target_compile_definitions(lte-softmodem PRIVATE E2_AGENT) + target_compile_definitions(lte-softmodem PRIVATE ${E2AP_VERSION} ${KPM_VERSION}) endif() add_executable(oairu @@ -2061,6 +2074,11 @@ target_link_libraries(nr-softmodem PRIVATE target_link_libraries(nr-softmodem PRIVATE pthread m CONFIG_LIB rt sctp) target_link_libraries(nr-softmodem PRIVATE ${T_LIB}) target_link_libraries(nr-softmodem PRIVATE asn1_nr_rrc_hdrs asn1_lte_rrc_hdrs) +target_link_libraries(nr-softmodem PRIVATE asn1_nr_rrc_hdrs asn1_lte_rrc_hdrs) +if(E2_AGENT) + target_compile_definitions(nr-softmodem PRIVATE ${E2AP_VERSION} ${KPM_VERSION}) +endif() + add_dependencies(nr-softmodem ldpc_orig ldpc_optim ldpc_optim8seg ldpc) diff --git a/executables/nr-softmodem.c b/executables/nr-softmodem.c index 31bde16b97..553f21a9fb 100644 --- a/executables/nr-softmodem.c +++ b/executables/nr-softmodem.c @@ -696,10 +696,13 @@ int main( int argc, char **argv ) { // OAI Wrapper e2_agent_args_t oai_args = RCconfig_NR_E2agent(); - AssertFatal(oai_args.sm_dir != NULL , "Please, specify the directory where the SMs are located in the config file, i.e., e2_agent = {near_ric_ip_addr = \"127.0.0.1\"; sm_dir = \"/usr/local/lib/flexric/\");} "); + AssertFatal(oai_args.sm_dir != NULL , "Please, specify the directory where the SMs are located in the config file, i.e., add in config file the next line: e2_agent = {near_ric_ip_addr = \"127.0.0.1\"; sm_dir = \"/usr/local/lib/flexric/\");} "); + AssertFatal(oai_args.ip != NULL , "Please, specify the IP address of the nearRT-RIC in the config file, i.e., e2_agent = {near_ric_ip_addr = \"127.0.0.1\"; sm_dir = \"/usr/local/lib/flexric/\""); - fr_args_t args = {.ip = oai_args.ip}; // init_fr_args(0, NULL); + printf("After RCconfig_NR_E2agent %s %s \n",oai_args.sm_dir, oai_args.ip ); + + fr_args_t args = { .ip = oai_args.ip }; // init_fr_args(0, NULL); memcpy(args.libs_dir, oai_args.sm_dir, 128); sleep(1); @@ -726,6 +729,7 @@ int main( int argc, char **argv ) { printf("[E2 NODE]: mcc = %d mnc = %d mnc_digit = %d nb_id = %d \n", mcc, mnc, mnc_digit_len, nb_id); + printf("[E2 NODE]: Args %s %s \n", args.ip, args.libs_dir); init_agent_api(mcc, mnc, mnc_digit_len, nb_id, cu_du_id, node_type, io, &args); // } diff --git a/openair2/E2AP/CMakeLists.txt b/openair2/E2AP/CMakeLists.txt index 865eac5ffa..c5603849a3 100644 --- a/openair2/E2AP/CMakeLists.txt +++ b/openair2/E2AP/CMakeLists.txt @@ -29,6 +29,9 @@ else() message(FATAL_ERROR "Unknown building type. Either choose a static or a dynamic library") endif() +####### +## E2AP encoding and versioning +####### set(E2AP_ENCODING "ASN" CACHE STRING "The E2AP encoding to use") set_property(CACHE E2AP_ENCODING PROPERTY STRINGS "ASN" "FLATBUFFERS") @@ -76,6 +79,35 @@ set(SM_ENCODING_GTP "PLAIN" CACHE STRING "The GTP SM encoding to use") set_property(CACHE SM_ENCODING_GTP PROPERTY STRINGS "PLAIN") message(STATUS "Selected GTP SM_ENCODING: ${SM_ENCODING_GTP}") + +if(E2AP_VERSION STREQUAL "E2AP_V1") + add_library(e2ap_ran_func_obj OBJECT + flexric/src/lib/e2ap/v1_01/e2ap_types/common/e2ap_ran_function.c ) + add_library(e2ap_plmn_obj OBJECT + flexric/src/lib/e2ap/v1_01/e2ap_types/common/e2ap_plmn.c ) + add_library(e2ap_global_node_id_obj OBJECT + flexric/src/lib/e2ap/v1_01/e2ap_types/common/e2ap_global_node_id.c ) +elseif(E2AP_VERSION STREQUAL "E2AP_V2") + add_library(e2ap_ran_func_obj OBJECT + flexric/src/lib/e2ap/v2_03/e2ap_types/common/e2ap_ran_function.c ) + add_library(e2ap_plmn_obj OBJECT + flexric/src/lib/e2ap/v2_03/e2ap_types/common/e2ap_plmn.c ) + add_library(e2ap_global_node_id_obj OBJECT + flexric/src/lib/e2ap/v2_03/e2ap_types/common/e2ap_global_node_id.c ) +elseif(E2AP_VERSION STREQUAL "E2AP_V3") + add_library(e2ap_ran_func_obj OBJECT + flexric/src/lib/e2ap/v3_01/e2ap_types/common/e2ap_ran_function.c ) + add_library(e2ap_plmn_obj OBJECT + flexric/src/lib/e2ap/v3_01/e2ap_types/common/e2ap_plmn.c ) + add_library(e2ap_global_node_id_obj OBJECT + flexric/src/lib/e2ap/v3_01/e2ap_types/common/e2ap_global_node_id.c ) +else() + message(FATAL_ERROR "E2AP Unknown version selected") +endif() + + + + ######## ### Flatbuffer ######## diff --git a/openair2/E2AP/RAN_FUNCTION/CMakeLists.txt b/openair2/E2AP/RAN_FUNCTION/CMakeLists.txt index ef92ddb0be..da550029e0 100644 --- a/openair2/E2AP/RAN_FUNCTION/CMakeLists.txt +++ b/openair2/E2AP/RAN_FUNCTION/CMakeLists.txt @@ -3,6 +3,8 @@ add_subdirectory(O-RAN) add_library(e2_ran_func STATIC init_ran_func.c + read_setup_ran.c + ../flexric/test/rnd/fill_rnd_data_e2_setup_req.c ) target_link_libraries(e2_ran_func @@ -10,3 +12,6 @@ target_link_libraries(e2_ran_func e2_ran_func_cust e2_ran_func_oran ) + +# This dependency sucks! Create pointers and forward declarations! +target_compile_definitions(e2_ran_func PRIVATE ${E2AP_VERSION} ${KPM_VERSION}) diff --git a/openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/CMakeLists.txt b/openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/CMakeLists.txt index bc5bfcb695..f2560ff838 100644 --- a/openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/CMakeLists.txt +++ b/openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/CMakeLists.txt @@ -16,3 +16,5 @@ add_library(e2_ran_func_cust STATIC ) target_link_libraries(e2_ran_func_cust PUBLIC asn1_nr_rrc nr_rrc asn1_nr_rrc_hdrs) +# This dependency sucks! Create pointers and forward declarations! +target_compile_definitions(e2_ran_func_cust PRIVATE ${E2AP_VERSION} ${KPM_VERSION} ) diff --git a/openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/ran_func_gtp.c b/openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/ran_func_gtp.c index 71200a1eb5..3550a80981 100644 --- a/openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/ran_func_gtp.c +++ b/openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/ran_func_gtp.c @@ -1,7 +1,14 @@ #include "ran_func_gtp.h" -#include "openair2/E2AP/flexric/test/rnd/fill_rnd_data_gtp.h" + #include +#include "openair2/E2AP/flexric/test/rnd/fill_rnd_data_gtp.h" +#include "common/ran_context.h" +#include "openair2/LAYER2/NR_MAC_gNB/mac_proto.h" +#include "openair2/E2AP/flexric/src/util/time_now_us.h" +#include "openair2/RRC/NR/rrc_gNB_UE_context.h" + + static const int mod_id = 0; diff --git a/openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/ran_func_gtp.h b/openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/ran_func_gtp.h index 5d28003c6f..0f12aa703a 100644 --- a/openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/ran_func_gtp.h +++ b/openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/ran_func_gtp.h @@ -2,10 +2,6 @@ #define RAN_FUNC_SM_GTP_READ_WRITE_AGENT_H #include "openair2/E2AP/flexric/src/agent/../sm/sm_io.h" -#include "common/ran_context.h" -#include "openair2/LAYER2/NR_MAC_gNB/mac_proto.h" -#include "openair2/E2AP/flexric/src/util/time_now_us.h" -#include "openair2/RRC/NR/rrc_gNB_UE_context.h" void read_gtp_sm(void*); diff --git a/openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/ran_func_pdcp.c b/openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/ran_func_pdcp.c index e65bd3ac0c..aa3cb39431 100644 --- a/openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/ran_func_pdcp.c +++ b/openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/ran_func_pdcp.c @@ -1,6 +1,17 @@ #include "ran_func_pdcp.h" -#include "openair2/E2AP/flexric/test/rnd/fill_rnd_data_pdcp.h" + #include +#include +#include + +#include "openair2/E2AP/flexric/test/rnd/fill_rnd_data_pdcp.h" +#include "common/ran_context.h" +#include "openair2/RRC/NR/rrc_gNB_UE_context.h" +#include "openair2/LAYER2/nr_pdcp/nr_pdcp_oai_api.h" +#include "openair2/LAYER2/nr_rlc/nr_rlc_oai_api.h" +#include "openair2/LAYER2/NR_MAC_gNB/mac_proto.h" +#include "openair2/E2AP/flexric/src/util/time_now_us.h" + static const int mod_id = 0; diff --git a/openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/ran_func_pdcp.h b/openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/ran_func_pdcp.h index ef16f3c123..01d70e8250 100644 --- a/openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/ran_func_pdcp.h +++ b/openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/ran_func_pdcp.h @@ -2,12 +2,6 @@ #define RAN_FUNC_SM_PDCP_READ_WRITE_AGENT_H #include "openair2/E2AP/flexric/src/agent/../sm/sm_io.h" -#include "common/ran_context.h" -#include "openair2/RRC/NR/rrc_gNB_UE_context.h" -#include "openair2/LAYER2/nr_pdcp/nr_pdcp_oai_api.h" -#include "openair2/LAYER2/nr_rlc/nr_rlc_oai_api.h" -#include "openair2/LAYER2/NR_MAC_gNB/mac_proto.h" -#include "openair2/E2AP/flexric/src/util/time_now_us.h" void read_pdcp_sm(void*); diff --git a/openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/ran_func_rlc.c b/openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/ran_func_rlc.c index 82c1a0b869..cb884b03ab 100644 --- a/openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/ran_func_rlc.c +++ b/openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/ran_func_rlc.c @@ -1,5 +1,12 @@ #include +#include +#include + #include "ran_func_rlc.h" +#include "common/ran_context.h" +#include "openair2/LAYER2/NR_MAC_gNB/mac_proto.h" +#include "openair2/LAYER2/nr_rlc/nr_rlc_oai_api.h" +#include "openair2/E2AP/flexric/src/util/time_now_us.h" #include "openair2/E2AP/flexric/test/rnd/fill_rnd_data_rlc.h" static diff --git a/openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/ran_func_rlc.h b/openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/ran_func_rlc.h index 0241401793..d49e56e9d3 100644 --- a/openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/ran_func_rlc.h +++ b/openair2/E2AP/RAN_FUNCTION/CUSTOMIZED/ran_func_rlc.h @@ -2,11 +2,6 @@ #define RAN_FUNC_SM_RLC_READ_WRITE_AGENT_H #include "openair2/E2AP/flexric/src/agent/../sm/sm_io.h" -#include "common/ran_context.h" -#include "openair2/LAYER2/NR_MAC_gNB/mac_proto.h" -#include "openair2/LAYER2/nr_rlc/nr_rlc_oai_api.h" -#include "openair2/E2AP/flexric/src/util/time_now_us.h" - void read_rlc_sm(void*); diff --git a/openair2/E2AP/RAN_FUNCTION/O-RAN/CMakeLists.txt b/openair2/E2AP/RAN_FUNCTION/O-RAN/CMakeLists.txt index ee5ccf01d0..3a1c042785 100644 --- a/openair2/E2AP/RAN_FUNCTION/O-RAN/CMakeLists.txt +++ b/openair2/E2AP/RAN_FUNCTION/O-RAN/CMakeLists.txt @@ -7,3 +7,4 @@ add_library(e2_ran_func_oran STATIC ) target_link_libraries(e2_ran_func_oran PUBLIC asn1_nr_rrc nr_rrc asn1_nr_rrc_hdrs) +target_compile_definitions(e2_ran_func_oran PRIVATE ${E2AP_VERSION} ${KPM_VERSION}) diff --git a/openair2/E2AP/RAN_FUNCTION/O-RAN/ran_func_kpm.c b/openair2/E2AP/RAN_FUNCTION/O-RAN/ran_func_kpm.c index 37054ad8fb..ea1735fcd8 100644 --- a/openair2/E2AP/RAN_FUNCTION/O-RAN/ran_func_kpm.c +++ b/openair2/E2AP/RAN_FUNCTION/O-RAN/ran_func_kpm.c @@ -20,7 +20,7 @@ typedef struct { static -matched_ues_mac_t filter_ues_by_s_nssai_in_du_or_monolithic(test_cond_e const * condition, int64_t const value) +matched_ues_mac_t filter_ues_by_s_nssai_in_du_or_monolithic(test_cond_e const condition, int64_t const value) { matched_ues_mac_t matched_ues = {.num_ues = 0, .ue_list = calloc(MAX_MOBILES_PER_GNB, sizeof(NR_UE_info_t)) }; assert(matched_ues.ue_list != NULL && "Memory exhausted"); @@ -37,7 +37,7 @@ matched_ues_mac_t filter_ues_by_s_nssai_in_du_or_monolithic(test_cond_e const * // Filter connected UEs by S-NSSAI test condition to get list of matched UEs // note: not possible to filter - switch (*condition) + switch (condition) { case EQUAL_TEST_COND: { @@ -73,7 +73,7 @@ typedef struct { } matched_ues_rrc_t; static -matched_ues_rrc_t filter_ues_by_s_nssai_in_cu(test_cond_e const * condition, int64_t const value) +matched_ues_rrc_t filter_ues_by_s_nssai_in_cu(test_cond_e const condition, int64_t const value) { matched_ues_rrc_t matched_ues = {.num_ues = 0, .rrc_ue_id_list = calloc(MAX_MOBILES_PER_GNB, sizeof(f1_ue_data_t)) }; assert(matched_ues.rrc_ue_id_list != NULL && "Memory exhausted"); @@ -85,7 +85,7 @@ matched_ues_rrc_t filter_ues_by_s_nssai_in_cu(test_cond_e const * condition, int ngap_gNB_ue_context_t *ngap_ue_context_list = ngap_get_ue_context(ue_context_p1->ue_context.rrc_ue_id); // Filter connected UEs by S-NSSAI test condition to get list of matched UEs - switch (*condition) + switch (condition) { case EQUAL_TEST_COND: assert(ngap_ue_context_list->gNB_instance[0].s_nssai[0][0].sST == value && "Please, check the condition for S-NSSAI. At the moment, OAI supports eMBB"); @@ -104,7 +104,7 @@ matched_ues_rrc_t filter_ues_by_s_nssai_in_cu(test_cond_e const * condition, int } static -nr_rlc_statistics_t get_rlc_stats_per_drb(NR_UE_info_t * const UE) +nr_rlc_statistics_t get_rlc_stats_per_drb(NR_UE_info_t const * UE) { assert(UE != NULL); @@ -195,13 +195,14 @@ gnb_du_e2sm_t fill_gnb_du_data(const f1_ue_data_t * rrc_ue_id) return gnb_du; } - -uint32_t last_dl_rlc_pdu_total_bytes[MAX_MOBILES_PER_GNB] = {0}; -uint32_t last_ul_rlc_pdu_total_bytes[MAX_MOBILES_PER_GNB] = {0}; -uint32_t last_dl_total_prbs[MAX_MOBILES_PER_GNB] = {0}; -uint32_t last_ul_total_prbs[MAX_MOBILES_PER_GNB] = {0}; -uint32_t last_dl_pdcp_sdu_total_bytes[MAX_MOBILES_PER_GNB] = {0}; -uint32_t last_ul_pdcp_sdu_total_bytes[MAX_MOBILES_PER_GNB] = {0}; +// Bad bad bad. Create a proper exponential moving average filter or at least, only read statistics +// Avoid coupling among sublayers +static uint32_t last_dl_rlc_pdu_total_bytes[MAX_MOBILES_PER_GNB] = {0}; +static uint32_t last_ul_rlc_pdu_total_bytes[MAX_MOBILES_PER_GNB] = {0}; +static uint32_t last_dl_total_prbs[MAX_MOBILES_PER_GNB] = {0}; +static uint32_t last_ul_total_prbs[MAX_MOBILES_PER_GNB] = {0}; +static uint32_t last_dl_pdcp_sdu_total_bytes[MAX_MOBILES_PER_GNB] = {0}; +static uint32_t last_ul_pdcp_sdu_total_bytes[MAX_MOBILES_PER_GNB] = {0}; static @@ -596,18 +597,23 @@ kpm_ind_msg_format_3_t fill_kpm_ind_msg_frm_3_in_monolithic(const matched_ues_ma msg_frm_3.meas_report_per_ue[i].ind_msg_format_1 = fill_kpm_ind_msg_frm_1_in_monolithic(&matched_ues.ue_list[i], i, rrc_ue_context_list->ue_context.rrc_ue_id, act_def_fr_1); } - return msg_frm_3; } - -static -kpm_ric_ind_hdr_format_1_t fill_kpm_ind_hdr_frm_1(void) +static +kpm_ric_ind_hdr_format_1_t kpm_ind_hdr_frm_1(void) { kpm_ric_ind_hdr_format_1_t hdr_frm_1 = {0}; - hdr_frm_1.collectStartTime = time_now_us(); - + int64_t const t = time_now_us(); +#if defined KPM_V2 + hdr_frm_1.collectStartTime = t/1000000; // seconds +#elif defined KPM_V3 + hdr_frm_1.collectStartTime = t; // microseconds +#else + static_assert(0!=0, "Undefined KPM SM Version"); +#endif + hdr_frm_1.fileformat_version = NULL; // Check E2 Node NG-RAN Type @@ -617,7 +623,7 @@ kpm_ric_ind_hdr_format_1_t fill_kpm_ind_hdr_frm_1(void) hdr_frm_1.sender_name->buf = calloc(strlen("My OAI-DU") + 1, sizeof(char)); memcpy(hdr_frm_1.sender_name->buf, "My OAI-DU", strlen("My OAI-DU")); hdr_frm_1.sender_name->len = strlen("My OAI-DU"); - + hdr_frm_1.sender_type = calloc(1, sizeof(byte_array_t)); hdr_frm_1.sender_type->buf = calloc(strlen("DU") + 1, sizeof(char)); memcpy(hdr_frm_1.sender_type->buf, "DU", strlen("DU")); @@ -629,7 +635,7 @@ kpm_ric_ind_hdr_format_1_t fill_kpm_ind_hdr_frm_1(void) hdr_frm_1.sender_name->buf = calloc(strlen("My OAI-CU") + 1, sizeof(char)); memcpy(hdr_frm_1.sender_name->buf, "My OAI-CU", strlen("My OAI-CU")); hdr_frm_1.sender_name->len = strlen("My OAI-CU"); - + hdr_frm_1.sender_type = calloc(1, sizeof(byte_array_t)); hdr_frm_1.sender_type->buf = calloc(strlen("CU") + 1, sizeof(char)); memcpy(hdr_frm_1.sender_type->buf, "CU", strlen("CU")); @@ -641,14 +647,15 @@ kpm_ric_ind_hdr_format_1_t fill_kpm_ind_hdr_frm_1(void) hdr_frm_1.sender_name->buf = calloc(strlen("My OAI-MONO") + 1, sizeof(char)); memcpy(hdr_frm_1.sender_name->buf, "My OAI-MONO", strlen("My OAI-MONO")); hdr_frm_1.sender_name->len = strlen("My OAI-MONO"); - + hdr_frm_1.sender_type = calloc(1, sizeof(byte_array_t)); hdr_frm_1.sender_type->buf = calloc(strlen("MONO") + 1, sizeof(char)); memcpy(hdr_frm_1.sender_type->buf, "MONO", strlen("MONO")); hdr_frm_1.sender_type->len = strlen("MONO"); + } else { + assert(0!=0 && "Unknown node type"); } - - + hdr_frm_1.vendor_name = calloc(1, sizeof(byte_array_t)); hdr_frm_1.vendor_name->buf = calloc(strlen("OAI") + 1, sizeof(char)); memcpy(hdr_frm_1.vendor_name->buf, "OAI", strlen("OAI")); @@ -657,87 +664,125 @@ kpm_ric_ind_hdr_format_1_t fill_kpm_ind_hdr_frm_1(void) return hdr_frm_1; } -static -kpm_ind_hdr_t fill_kpm_ind_hdr(void) +kpm_ind_hdr_t kpm_ind_hdr(void) { kpm_ind_hdr_t hdr = {0}; hdr.type = FORMAT_1_INDICATION_HEADER; - hdr.kpm_ric_ind_hdr_format_1 = fill_kpm_ind_hdr_frm_1(); + hdr.kpm_ric_ind_hdr_format_1 = kpm_ind_hdr_frm_1(); return hdr; } - void read_kpm_sm(void* data) { assert(data != NULL); - //assert(data->type == KPM_STATS_V3_0); + // assert(data->type == KPM_STATS_V3_0); kpm_rd_ind_data_t* const kpm = (kpm_rd_ind_data_t*)data; - assert(kpm->act_def!= NULL && "Cannot be NULL"); + assert(kpm->act_def != NULL && "Cannot be NULL"); // 7.8 Supported RIC Styles and E2SM IE Formats // Action Definition Format 4 corresponds to Indication Message Format 3 - switch (kpm->act_def->type) - { - case FORMAT_4_ACTION_DEFINITION: - { - kpm->ind.hdr = fill_kpm_ind_hdr(); - - kpm->ind.msg.type = FORMAT_3_INDICATION_MESSAGE; + switch (kpm->act_def->type) { + case FORMAT_4_ACTION_DEFINITION: { + kpm->ind.hdr = kpm_ind_hdr(); - // Filter the UE by the test condition criteria - for (size_t i = 0; iact_def->frm_4.matching_cond_lst_len; i++) - { - switch (kpm->act_def->frm_4.matching_cond_lst[i].test_info_lst.test_cond_type) - { - case S_NSSAI_TEST_COND_TYPE: - assert(kpm->act_def->frm_4.matching_cond_lst[i].test_info_lst.S_NSSAI == TRUE_TEST_COND_TYPE && "Must be true"); - - // Check E2 Node NG-RAN Type - if (NODE_IS_DU(RC.nrrrc[0]->node_type)) - { - matched_ues_mac_t matched_ues = filter_ues_by_s_nssai_in_du_or_monolithic(kpm->act_def->frm_4.matching_cond_lst[i].test_info_lst.test_cond, *kpm->act_def->frm_4.matching_cond_lst[i].test_info_lst.int_value); - kpm->ind.msg.frm_3 = fill_kpm_ind_msg_frm_3_in_du(matched_ues, &kpm->act_def->frm_4.action_def_format_1); - } - else if (NODE_IS_CU(RC.nrrrc[0]->node_type)) - { - matched_ues_rrc_t matched_ues = filter_ues_by_s_nssai_in_cu(kpm->act_def->frm_4.matching_cond_lst[i].test_info_lst.test_cond, *kpm->act_def->frm_4.matching_cond_lst[i].test_info_lst.int_value); - kpm->ind.msg.frm_3 = fill_kpm_ind_msg_frm_3_in_cu(matched_ues, &kpm->act_def->frm_4.action_def_format_1); - } - else if (NODE_IS_MONOLITHIC(RC.nrrrc[0]->node_type)) - { - matched_ues_mac_t matched_ues = filter_ues_by_s_nssai_in_du_or_monolithic(kpm->act_def->frm_4.matching_cond_lst[i].test_info_lst.test_cond, *kpm->act_def->frm_4.matching_cond_lst[i].test_info_lst.int_value); - kpm->ind.msg.frm_3 = fill_kpm_ind_msg_frm_3_in_monolithic(matched_ues, &kpm->act_def->frm_4.action_def_format_1); - } - else - { - assert(false && "NG-RAN Type not yet implemented"); - } + kpm->ind.msg.type = FORMAT_3_INDICATION_MESSAGE; + // Filter the UE by the test condition criteria + kpm_act_def_format_4_t const* frm_4 = &kpm->act_def->frm_4; // 8.2.1.2.4 + for (size_t i = 0; i < frm_4->matching_cond_lst_len; i++) { + switch (frm_4->matching_cond_lst[i].test_info_lst.test_cond_type) { + case GBR_TEST_COND_TYPE: { + assert(0 != 0 && "Not implemented"); + break; + } + case AMBR_TEST_COND_TYPE: { + assert(0 != 0 && "Not implemented"); + break; + } + case IsStat_TEST_COND_TYPE: { + assert(0 != 0 && "Not implemented"); + break; + } + case IsCatM_TEST_COND_TYPE: { + assert(0 != 0 && "Not implemented"); + break; + } - break; - - default: - assert(false && "Test condition type not yet implemented"); + case DL_RSRP_TEST_COND_TYPE: { + assert(0 != 0 && "Not implemented"); + break; + } + + case DL_RSRQ_TEST_COND_TYPE: { + assert(0 != 0 && "Not implemented"); + break; + } + + case UL_RSRP_TEST_COND_TYPE: { + assert(0 != 0 && "Not implemented"); + break; + } + + case CQI_TEST_COND_TYPE: { + // This is a bad idea. Done only to check FlexRIC xAPP + printf("CQI not implemented!. Randomly filling the data \n"); + goto rnd_data_label; + break; + } + + case fiveQI_TEST_COND_TYPE: { + assert(0 != 0 && "Not implemented"); + break; + } + + case QCI_TEST_COND_TYPE: { + ; + assert(0 != 0 && "Not implemented"); + break; + } + case S_NSSAI_TEST_COND_TYPE: { + assert(frm_4->matching_cond_lst[i].test_info_lst.S_NSSAI == TRUE_TEST_COND_TYPE && "Must be true"); + assert(frm_4->matching_cond_lst[i].test_info_lst.test_cond != NULL && "Even though is optional.."); + assert(frm_4->matching_cond_lst[i].test_info_lst.int_value != NULL && "Even though is optional.."); + + test_cond_e const test_cond = *frm_4->matching_cond_lst[i].test_info_lst.test_cond; + int64_t const value = *frm_4->matching_cond_lst[i].test_info_lst.int_value; + // Check E2 Node NG-RAN Type + if (NODE_IS_DU(RC.nrrrc[0]->node_type)) { + matched_ues_mac_t matched_ues = filter_ues_by_s_nssai_in_du_or_monolithic(test_cond, value); + kpm->ind.msg.frm_3 = fill_kpm_ind_msg_frm_3_in_du(matched_ues, &frm_4->action_def_format_1); + } else if (NODE_IS_CU(RC.nrrrc[0]->node_type)) { + matched_ues_rrc_t matched_ues = filter_ues_by_s_nssai_in_cu(test_cond, value); + kpm->ind.msg.frm_3 = fill_kpm_ind_msg_frm_3_in_cu(matched_ues, &frm_4->action_def_format_1); + } else if (NODE_IS_MONOLITHIC(RC.nrrrc[0]->node_type)) { + matched_ues_mac_t matched_ues = filter_ues_by_s_nssai_in_du_or_monolithic(test_cond, value); + kpm->ind.msg.frm_3 = fill_kpm_ind_msg_frm_3_in_monolithic(matched_ues, &frm_4->action_def_format_1); + } else { + assert(false && "NG-RAN Type not implemented"); + } + + break; + } + + default: + assert(false && "Unknown Test condition"); + } } + break; } - break; - } - - default: - { - kpm->ind.hdr = fill_rnd_kpm_ind_hdr(); - kpm->ind.msg = fill_rnd_kpm_ind_msg(); + default: { + rnd_data_label: + kpm->ind.hdr = fill_rnd_kpm_ind_hdr(); + kpm->ind.msg = fill_rnd_kpm_ind_msg(); - break; + break; + } } - - } - } void read_kpm_setup_sm(void* e2ap) diff --git a/openair2/E2AP/RAN_FUNCTION/O-RAN/ran_func_rc.c b/openair2/E2AP/RAN_FUNCTION/O-RAN/ran_func_rc.c index 5c6777d5a3..d482cfffb6 100644 --- a/openair2/E2AP/RAN_FUNCTION/O-RAN/ran_func_rc.c +++ b/openair2/E2AP/RAN_FUNCTION/O-RAN/ran_func_rc.c @@ -2,6 +2,8 @@ #include "../../flexric/test/rnd/fill_rnd_data_rc.h" #include "../../flexric/src/sm/rc_sm/ie/ir/lst_ran_param.h" #include "../../flexric/src/sm/rc_sm/ie/ir/ran_param_list.h" +#include "../../flexric/src/agent/e2_agent_api.h" + #include #include #include diff --git a/openair2/E2AP/RAN_FUNCTION/init_ran_func.c b/openair2/E2AP/RAN_FUNCTION/init_ran_func.c index ecd1dc6ec7..e7883e1337 100644 --- a/openair2/E2AP/RAN_FUNCTION/init_ran_func.c +++ b/openair2/E2AP/RAN_FUNCTION/init_ran_func.c @@ -1,4 +1,6 @@ #include "init_ran_func.h" +#include "read_setup_ran.h" +#include "../flexric/src/agent/e2_agent_api.h" #include "CUSTOMIZED/ran_func_mac.h" #include "CUSTOMIZED/ran_func_rlc.h" #include "CUSTOMIZED/ran_func_pdcp.h" @@ -67,6 +69,10 @@ sm_io_ag_ran_t init_ran_func_ag(void) init_write_ctrl(&io.write_ctrl_tbl); init_write_subs(&io.write_subs_tbl); +#if defined(E2AP_V2) || defined(E2AP_V3) + io.read_setup_ran = read_setup_ran; +#endif + return io; } diff --git a/openair2/E2AP/RAN_FUNCTION/read_setup_ran.c b/openair2/E2AP/RAN_FUNCTION/read_setup_ran.c new file mode 100644 index 0000000000..9967a23902 --- /dev/null +++ b/openair2/E2AP/RAN_FUNCTION/read_setup_ran.c @@ -0,0 +1,42 @@ +/* + * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The OpenAirInterface Software Alliance licenses this file to You under + * the OAI Public License, Version 1.1 (the "License"); you may not use this file + * except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.openairinterface.org/?page_id=698 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + *------------------------------------------------------------------------------- + * For more information about the OpenAirInterface (OAI) Software Alliance: + * contact@openairinterface.org + */ + +#include "read_setup_ran.h" +#include "../../E2AP/flexric/src/lib/e2ap/e2ap_node_component_config_add_wrapper.h" +#include "../../E2AP/flexric/test/rnd/fill_rnd_data_e2_setup_req.h" +#include +#include + +void read_setup_ran(void* data) +{ + assert(data != NULL); +#ifdef E2AP_V1 + +#elif defined(E2AP_V2) || defined(E2AP_V3) + *((e2ap_node_component_config_add_t*)data) = fill_e2ap_node_component_config_add(); +#else + static_assert(0!=0, "Unknown E2AP version"); +#endif + +} + + + diff --git a/openair2/E2AP/RAN_FUNCTION/read_setup_ran.h b/openair2/E2AP/RAN_FUNCTION/read_setup_ran.h new file mode 100644 index 0000000000..2b4c83f2e1 --- /dev/null +++ b/openair2/E2AP/RAN_FUNCTION/read_setup_ran.h @@ -0,0 +1,27 @@ +/* + * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The OpenAirInterface Software Alliance licenses this file to You under + * the OAI Public License, Version 1.1 (the "License"); you may not use this file + * except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.openairinterface.org/?page_id=698 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + *------------------------------------------------------------------------------- + * For more information about the OpenAirInterface (OAI) Software Alliance: + * contact@openairinterface.org + */ + +#ifndef READ_SETUP_RAN_E2_AGENT_H +#define READ_SETUP_RAN_E2_AGENT_H + +void read_setup_ran(void* data); + +#endif diff --git a/openair2/E2AP/README.md b/openair2/E2AP/README.md index 5da7c33359..f5031454a3 100644 --- a/openair2/E2AP/README.md +++ b/openair2/E2AP/README.md @@ -11,7 +11,7 @@ Please see [NOTICE](NOTICE.md) file for third party software that is included in # Overview -This tutorial describes the steps of deployment 5G OAI RAN, with integrated E2 agent, and FlexRIC, O-RAN compliant nearRT-RIC. +This tutorial describes the steps of deployment 5G OAI RAN, with integrated E2 agent and a nearRT-RIC using O-RAN compliant FlexRIC. # 1. Installation @@ -29,9 +29,10 @@ This tutorial describes the steps of deployment 5G OAI RAN, with integrated E2 a ```bash git clone https://github.com/swig/swig.git cd swig + git checkout release-4.1 ./autogen.sh ./configure --prefix=/usr/ - make + make -j8 make install ``` @@ -57,12 +58,15 @@ git clone https://gitlab.eurecom.fr/oai/openairinterface5g oai cd oai/ ``` -### 2.1.2 Build OAI +### 2.1.2 Build OAI with E2 Agent + +- By default, OAI will build the E2 Agent with E2AP v2 and KPM v2. If you want a different version, edit the variable E2AP\_VERSION and KPM\_VERSION at OAI's CMakeLists.txt file. + ```bash cd cmake_targets/ ./build_oai -I -w SIMU --gNB --nrUE --build-e2 --ninja ``` -If the flexric folder is empty, try manually the following commands +If the openair2/E2AP/flexric folder is empty, try manually the following commands ```bash git submodule init @@ -74,15 +78,18 @@ git submodule update * `--gNB` is to build the `nr-softmodem` and `nr-cuup` executables and all required shared libraries * `--nrUE` is to build the `nr-uesoftmodem` executable and all required shared libraries * `--ninja` is to use the ninja build tool, which speeds up compilation - * `--build-e2` option is to use the E2 agent, integrated within gNB. + * `--build-e2` option is to use the E2 agent, integrated within RAN. ## 2.2 FlexRIC +- By default, FlexRIC will build the nearRT-RIC with E2AP v2 and KPM v2. If you want a different version, edit the variable E2AP\_VERSION and KPM\_VERSION at FlexRIC's CMakeLists.txt file. Note that OAI's and FlexRIC's E2AP\_VERSION and KPM\_VERSION need to match due to O-RAN incompatibilities among versions. + + ### 2.2.1 Clone the FlexRIC repository ```bash git clone https://gitlab.eurecom.fr/mosaic5g/flexric flexric cd flexric/ -git checkout 8ee3aca107a9da8ccf425e623bed18cd40a31fa1 +git checkout 7a55f02efaa81fe143280ad49b92cfbfc0cd3320 ``` ### 2.2.2 Build FlexRIC @@ -98,7 +105,8 @@ sudo make install By default the service model libraries will be installed in the path `/usr/local/lib/flexric` while the configuration file in `/usr/local/etc/flexric`. Available SMs in this version are: -* KPM v03.00 (xapp_kpm_moni) +* KPM v02.03 and KPM v03.00 (xapp_kpm_moni) +* RC v01.03 (xapp_kpm_rc) * GTP (xapp_gtp_moni) * MAC + RLC + PDCP (xapp_mac_rlc_pdcp_moni) @@ -106,7 +114,7 @@ If you are interested in TC and SLICE SMs, please follow the instructions at htt # 3. Start the process -In order to configure E2 agent, please, add the following block in the configuration file: +In order to configure E2 agent, please, add the following block in OAI's configuration file: ```bash e2_agent = { near_ric_ip_addr = "127.0.0.1"; diff --git a/openair2/E2AP/flexric b/openair2/E2AP/flexric index 8ee3aca107..89b2886706 160000 --- a/openair2/E2AP/flexric +++ b/openair2/E2AP/flexric @@ -1 +1 @@ -Subproject commit 8ee3aca107a9da8ccf425e623bed18cd40a31fa1 +Subproject commit 89b2886706d08957749836e590af73bd45184e55 From 999bdc01c862091c833973e94c1ebe79bb1720e0 Mon Sep 17 00:00:00 2001 From: Quency Lin Date: Wed, 4 Oct 2023 10:14:51 +0200 Subject: [PATCH 29/47] fix: Remove miss-hardcoded #define USE_128BIT --- openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c | 1 - 1 file changed, 1 deletion(-) diff --git a/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c b/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c index eb99669564..de5639a149 100644 --- a/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c +++ b/openair1/PHY/NR_TRANSPORT/nr_ulsch_llr_computation.c @@ -38,7 +38,6 @@ #ifdef __aarch64__ #define USE_128BIT #endif -#define USE_128BIT //---------------------------------------------------------------------------------------------- // QPSK From 0ffb01b9c3ea0b0f3fa94b868e9fc7d8ad711c96 Mon Sep 17 00:00:00 2001 From: mir Date: Wed, 4 Oct 2023 14:20:30 +0200 Subject: [PATCH 30/47] NG-RAN was not compiling due to struct definition missing --- openair2/E2AP/flexric | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/openair2/E2AP/flexric b/openair2/E2AP/flexric index 89b2886706..2e49853d98 160000 --- a/openair2/E2AP/flexric +++ b/openair2/E2AP/flexric @@ -1 +1 @@ -Subproject commit 89b2886706d08957749836e590af73bd45184e55 +Subproject commit 2e49853d9843597c0d61eca6651bcfc4e0166c3f From d6285354e49aa56b5c294195485026756a99d60c Mon Sep 17 00:00:00 2001 From: Robert Schmidt Date: Wed, 4 Oct 2023 14:30:27 +0200 Subject: [PATCH 31/47] Properly formulate assert message --- openair2/RRC/NR/rrc_gNB.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/openair2/RRC/NR/rrc_gNB.c b/openair2/RRC/NR/rrc_gNB.c index e5dcc79dfd..e7f36ff9c6 100644 --- a/openair2/RRC/NR/rrc_gNB.c +++ b/openair2/RRC/NR/rrc_gNB.c @@ -269,7 +269,7 @@ static int get_ssb_arfcn(const f1ap_served_cell_info_t *cell_info, const NR_MIB_ // taken out (but the reestablishment will likely not work). const NR_ServingCellConfigCommon_t *scc = RC.nrmac[0]->common_channels[0].ServingCellConfigCommon; uint32_t scc_ssb_arfcn = *scc->downlinkConfigCommon->frequencyInfoDL->absoluteFrequencySSB; - AssertFatal(ssb_arfcn == scc_ssb_arfcn, "fuck: SCC SSB ARFCN original %d vs. computed %d\n", scc_ssb_arfcn, ssb_arfcn); + AssertFatal(ssb_arfcn == scc_ssb_arfcn, "mismatch of SCC SSB ARFCN original %d vs. computed %d! Note: you can remove this Assert, the gNB might run but UE connection instable\n", scc_ssb_arfcn, ssb_arfcn); } return ssb_arfcn; From ed4c634186b65f75f479578d1c01e19e63f300aa Mon Sep 17 00:00:00 2001 From: Raphael Defosseux Date: Wed, 4 Oct 2023 14:00:35 +0200 Subject: [PATCH 32/47] fix(ci): printing the warning and error lines for CI purposes Signed-off-by: Raphael Defosseux --- ci-scripts/cls_containerize.py | 8 ++++---- cmake_targets/tools/build_helper | 2 ++ 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/ci-scripts/cls_containerize.py b/ci-scripts/cls_containerize.py index 17d96e32c7..dab8b0b64c 100644 --- a/ci-scripts/cls_containerize.py +++ b/ci-scripts/cls_containerize.py @@ -433,7 +433,7 @@ class Containerize(): if ret.returncode != 0: logging.error('\u001B[1m Could not build properly ran-base\u001B[0m') # Recover the name of the failed container? - cmd.run(f"{self.cli} ps --quiet --filter \"status=exited\" -n1 | xargs {self.cli} rm -f") + cmd.run(f"{self.cli} ps --quiet --filter \"status=exited\" -n1 | xargs --no-run-if-empty {self.cli} rm -f") cmd.run(f"{self.cli} image prune --force") cmd.close() logging.error('\u001B[1m Building OAI Images Failed\u001B[0m') @@ -466,8 +466,8 @@ class Containerize(): cmd.run(f'sed -i -e "s#{baseImage}:latest#{baseImage}:{baseTag}#" docker/Dockerfile.{pattern}{self.dockerfileprefix}') if image != 'ran-build': cmd.run(f'sed -i -e "s#ran-build:latest#ran-build:{imageTag}#" docker/Dockerfile.{pattern}{self.dockerfileprefix}') - cmd.run(f'{self.cli} build {self.cliBuildOptions} --target {image} --tag {image}:{imageTag} --file docker/Dockerfile.{pattern}{self.dockerfileprefix} . > cmake_targets/log/{image}.log 2>&1', timeout=1200) - if image == 'ran-build': + ret = cmd.run(f'{self.cli} build {self.cliBuildOptions} --target {image} --tag {image}:{imageTag} --file docker/Dockerfile.{pattern}{self.dockerfileprefix} . > cmake_targets/log/{image}.log 2>&1', timeout=1200) + if image == 'ran-build' and ret.returncode == 0: cmd.run(f"docker run --name test-log -d {image}:{imageTag} /bin/true") cmd.run(f"docker cp test-log:/oai-ran/cmake_targets/log/ cmake_targets/log/{image}/") cmd.run(f"docker rm -f test-log") @@ -479,7 +479,7 @@ class Containerize(): logging.error('\u001B[1m Could not build properly ' + image + '\u001B[0m') status = False # Here we should check if the last container corresponds to a failed command and destroy it - cmd.run(f"{self.cli} ps --quiet --filter \"status=exited\" -n1 | xargs {self.cli} rm -f") + cmd.run(f"{self.cli} ps --quiet --filter \"status=exited\" -n1 | xargs --no-run-if-empty {self.cli} rm -f") allImagesSize[image] = 'N/A -- Build Failed' break else: diff --git a/cmake_targets/tools/build_helper b/cmake_targets/tools/build_helper index cbd9f7265b..d9237b57ba 100755 --- a/cmake_targets/tools/build_helper +++ b/cmake_targets/tools/build_helper @@ -233,6 +233,8 @@ compilations() { $CMAKE --build . $verbose --target $targets -- -j$(nproc) ret=$? } > $dlog/$logfile 2>&1 + # Print the errors and warnings for CI purposes + egrep -A3 "warning:|error:" $dlog/$logfile || true check_warnings "$dlog/$logfile" if [[ $ret -eq 0 ]]; then echo_success "$targets compiled" From 072620aa0ae2415b33481495045f0a689b9f7a69 Mon Sep 17 00:00:00 2001 From: Robert Schmidt Date: Wed, 4 Oct 2023 16:51:45 +0200 Subject: [PATCH 33/47] Make different Point A/SSB ARFCN multiple of 30kHz --- ci-scripts/conf_files/gnb.sa.band66.106prb.rfsim.conf | 4 ++-- ci-scripts/yaml_files/5g_fdd_rfsimulator/docker-compose.yaml | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/ci-scripts/conf_files/gnb.sa.band66.106prb.rfsim.conf b/ci-scripts/conf_files/gnb.sa.band66.106prb.rfsim.conf index 655f083b57..66deda5e59 100644 --- a/ci-scripts/conf_files/gnb.sa.band66.106prb.rfsim.conf +++ b/ci-scripts/conf_files/gnb.sa.band66.106prb.rfsim.conf @@ -32,7 +32,7 @@ gNBs = absoluteFrequencySSB = 432990; dl_frequencyBand = 66; # this is 3600 MHz - dl_absoluteFrequencyPointA = 430000; + dl_absoluteFrequencyPointA = 430002; #scs-SpecificCarrierList dl_offstToCarrier = 0; # subcarrierSpacing @@ -53,7 +53,7 @@ gNBs = #uplinkConfigCommon #frequencyInfoUL ul_frequencyBand = 66; - ul_absoluteFrequencyPointA = 350000; + ul_absoluteFrequencyPointA = 350002; #scs-SpecificCarrierList ul_offstToCarrier = 0; # subcarrierSpacing diff --git a/ci-scripts/yaml_files/5g_fdd_rfsimulator/docker-compose.yaml b/ci-scripts/yaml_files/5g_fdd_rfsimulator/docker-compose.yaml index 93da3f9f0f..8cf83e8943 100644 --- a/ci-scripts/yaml_files/5g_fdd_rfsimulator/docker-compose.yaml +++ b/ci-scripts/yaml_files/5g_fdd_rfsimulator/docker-compose.yaml @@ -185,7 +185,7 @@ services: privileged: true container_name: rfsim5g-oai-nr-ue environment: - USE_ADDITIONAL_OPTIONS: -E --sa --rfsim -r 106 --numerology 1 --uicc0.imsi 208990100001100 --band 66 -C 2169080000 --CO -400000000 --ssb 378 --rfsimulator.serveraddr 192.168.71.140 --log_config.global_log_options level,nocolor,time + USE_ADDITIONAL_OPTIONS: -E --sa --rfsim -r 106 --numerology 1 --uicc0.imsi 208990100001100 --band 66 -C 2169090000 --CO -400000000 --ssb 378 --rfsimulator.serveraddr 192.168.71.140 --log_config.global_log_options level,nocolor,time depends_on: - oai-gnb networks: From 06efde1ed9f2797fe3783090ceee2abf05e52cb2 Mon Sep 17 00:00:00 2001 From: Robert Schmidt Date: Wed, 4 Oct 2023 19:03:37 +0200 Subject: [PATCH 34/47] u0.25prb --- ci-scripts/conf_files/gnb.sa.band66.u0.25prb.rfsim.conf | 4 ++-- .../yaml_files/5g_rfsimulator_u0_25prb/docker-compose.yaml | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/ci-scripts/conf_files/gnb.sa.band66.u0.25prb.rfsim.conf b/ci-scripts/conf_files/gnb.sa.band66.u0.25prb.rfsim.conf index c03bfd9b77..b72217d5e6 100644 --- a/ci-scripts/conf_files/gnb.sa.band66.u0.25prb.rfsim.conf +++ b/ci-scripts/conf_files/gnb.sa.band66.u0.25prb.rfsim.conf @@ -32,7 +32,7 @@ gNBs = absoluteFrequencySSB = 430590; dl_frequencyBand = 66; # this is 2150 MHz - dl_absoluteFrequencyPointA = 430000; + dl_absoluteFrequencyPointA = 430002; #scs-SpecificCarrierList dl_offstToCarrier = 0; # subcarrierSpacing @@ -54,7 +54,7 @@ gNBs = #frequencyInfoUL ul_frequencyBand = 66; # this is 1750 MHz - ul_absoluteFrequencyPointA = 350000; + ul_absoluteFrequencyPointA = 350002; #scs-SpecificCarrierList ul_offstToCarrier = 0; # subcarrierSpacing diff --git a/ci-scripts/yaml_files/5g_rfsimulator_u0_25prb/docker-compose.yaml b/ci-scripts/yaml_files/5g_rfsimulator_u0_25prb/docker-compose.yaml index 14a989934b..6055138e65 100644 --- a/ci-scripts/yaml_files/5g_rfsimulator_u0_25prb/docker-compose.yaml +++ b/ci-scripts/yaml_files/5g_rfsimulator_u0_25prb/docker-compose.yaml @@ -186,7 +186,7 @@ services: privileged: true container_name: rfsim5g-oai-nr-ue environment: - USE_ADDITIONAL_OPTIONS: --sa --rfsim -r 25 --numerology 0 --uicc0.imsi 208990100001100 --band 66 -C 2152250000 --CO -400000000 --ssb 76 --rfsimulator.serveraddr 192.168.71.140 --log_config.global_log_options level,nocolor,time + USE_ADDITIONAL_OPTIONS: --sa --rfsim -r 25 --numerology 0 --uicc0.imsi 208990100001100 --band 66 -C 2152260000 --CO -400000000 --ssb 76 --rfsimulator.serveraddr 192.168.71.140 --log_config.global_log_options level,nocolor,time depends_on: - oai-gnb networks: From 9bee85dbe224bc90ec43ed85d7bbf87b5a29a06f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?R=C3=BAben=20Soares=20da=20Silva?= Date: Wed, 4 Oct 2023 18:46:54 +0100 Subject: [PATCH 35/47] Remove previously added bwp_size and bwp_start fields from struct fapi_nr_dl_config_csirs_pdu_rel15_t. Create function to obtain nfapi_nr_dl_tti_csi_rs_pdu_rel15_t from fapi_nr_dl_config_csirs_pdu_rel15_t without bwp_size and bwp_start. Replace previously problematic cast with call to created function. --- .../nfapi/public_inc/fapi_nr_ue_interface.h | 2 -- openair1/PHY/NR_UE_TRANSPORT/csi_rx.c | 22 ++++++++++++++++++- openair2/LAYER2/NR_MAC_UE/nr_ue_scheduler.c | 2 -- 3 files changed, 21 insertions(+), 5 deletions(-) diff --git a/nfapi/open-nFAPI/nfapi/public_inc/fapi_nr_ue_interface.h b/nfapi/open-nFAPI/nfapi/public_inc/fapi_nr_ue_interface.h index 2ac6dd4429..3dc6e930b7 100644 --- a/nfapi/open-nFAPI/nfapi/public_inc/fapi_nr_ue_interface.h +++ b/nfapi/open-nFAPI/nfapi/public_inc/fapi_nr_ue_interface.h @@ -500,8 +500,6 @@ typedef struct { typedef struct { - uint16_t bwp_size; // Needed for SCF222 10.02 - uint16_t bwp_start; // Needed for SCF222 10.02 uint8_t subcarrier_spacing; // subcarrierSpacing [3GPP TS 38.211, sec 4.2], Value:0->4 uint8_t cyclic_prefix; // Cyclic prefix type [3GPP TS 38.211, sec 4.2], 0: Normal; 1: Extended uint16_t start_rb; // PRB where this CSI resource starts related to common resource block #0 (CRB#0). Only multiples of 4 are allowed. [3GPP TS 38.331, sec 6.3.2 parameter CSIFrequencyOccupation], Value: 0 ->274 diff --git a/openair1/PHY/NR_UE_TRANSPORT/csi_rx.c b/openair1/PHY/NR_UE_TRANSPORT/csi_rx.c index 9671f301c7..a64cbe0e39 100644 --- a/openair1/PHY/NR_UE_TRANSPORT/csi_rx.c +++ b/openair1/PHY/NR_UE_TRANSPORT/csi_rx.c @@ -834,6 +834,26 @@ int nr_ue_csi_im_procedures(PHY_VARS_NR_UE *ue, UE_nr_rxtx_proc_t *proc, c16_t r return 0; } +nfapi_nr_dl_tti_csi_rs_pdu_rel15_t *convert_csirs_pdu(fapi_nr_dl_config_csirs_pdu_rel15_t *csirs_config_pdu) +{ + nfapi_nr_dl_tti_csi_rs_pdu_rel15_t *dl_tti_csi_rs_pdu = calloc(1, sizeof(nfapi_nr_dl_tti_csi_rs_pdu_rel15_t)); + dl_tti_csi_rs_pdu->subcarrier_spacing = csirs_config_pdu->subcarrier_spacing; + dl_tti_csi_rs_pdu->cyclic_prefix = csirs_config_pdu->cyclic_prefix; + dl_tti_csi_rs_pdu->start_rb = csirs_config_pdu->start_rb; + dl_tti_csi_rs_pdu->nr_of_rbs = csirs_config_pdu->nr_of_rbs; + dl_tti_csi_rs_pdu->csi_type = csirs_config_pdu->csi_type; + dl_tti_csi_rs_pdu->row = csirs_config_pdu->row; + dl_tti_csi_rs_pdu->freq_domain = csirs_config_pdu->freq_domain; + dl_tti_csi_rs_pdu->symb_l0 = csirs_config_pdu->symb_l0; + dl_tti_csi_rs_pdu->symb_l1 = csirs_config_pdu->symb_l1; + dl_tti_csi_rs_pdu->cdm_type = csirs_config_pdu->cdm_type; + dl_tti_csi_rs_pdu->freq_density = csirs_config_pdu->freq_density; + dl_tti_csi_rs_pdu->scramb_id = csirs_config_pdu->scramb_id; + dl_tti_csi_rs_pdu->power_control_offset = csirs_config_pdu->power_control_offset; + dl_tti_csi_rs_pdu->power_control_offset_ss = csirs_config_pdu->power_control_offset_ss; + return dl_tti_csi_rs_pdu; +} + void nr_ue_csi_rs_procedures(PHY_VARS_NR_UE *ue, UE_nr_rxtx_proc_t *proc, c16_t rxdataF[][ue->frame_parms.samples_per_slot_wCP]) { @@ -891,7 +911,7 @@ void nr_ue_csi_rs_procedures(PHY_VARS_NR_UE *ue, UE_nr_rxtx_proc_t *proc, c16_t ue->nr_csi_info->csi_rs_generated_signal, AMP, ue->nr_csi_info, - (nfapi_nr_dl_tti_csi_rs_pdu_rel15_t *) csirs_config_pdu, + convert_csirs_pdu((fapi_nr_dl_config_csirs_pdu_rel15_t*)&ue->csirs_vars[gNB_id]->csirs_config_pdu), proc->nr_slot_rx, &N_cdm_groups, &CDM_group_size, diff --git a/openair2/LAYER2/NR_MAC_UE/nr_ue_scheduler.c b/openair2/LAYER2/NR_MAC_UE/nr_ue_scheduler.c index 86cf6ff281..e2548fc7b1 100644 --- a/openair2/LAYER2/NR_MAC_UE/nr_ue_scheduler.c +++ b/openair2/LAYER2/NR_MAC_UE/nr_ue_scheduler.c @@ -2308,8 +2308,6 @@ void nr_schedule_csirs_reception(NR_UE_MAC_INST_t *mac, int frame, int slot) { continue; LOG_D(MAC,"Scheduling reception of CSI-RS in frame %d slot %d\n", frame, slot); fapi_nr_dl_config_csirs_pdu_rel15_t *csirs_config_pdu = &dl_config->dl_config_list[dl_config->number_pdus].csirs_config_pdu.csirs_config_rel15; - csirs_config_pdu->bwp_size = bwp_size; - csirs_config_pdu->bwp_start = bwp_start; csirs_config_pdu->measurement_bitmap = set_csirs_measurement_bitmap(csi_measconfig, csi_res_id); NR_CSI_RS_ResourceMapping_t resourceMapping = nzpcsi->resourceMapping; csirs_config_pdu->subcarrier_spacing = mu; From 58134a29d959cfcddc9ff93d0c28887b198674b0 Mon Sep 17 00:00:00 2001 From: mir Date: Thu, 5 Oct 2023 14:54:39 +0200 Subject: [PATCH 36/47] Fixes from Teodora applied --- openair2/E2AP/README.md | 2 +- openair2/E2AP/flexric | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/openair2/E2AP/README.md b/openair2/E2AP/README.md index f5031454a3..7fa1150edf 100644 --- a/openair2/E2AP/README.md +++ b/openair2/E2AP/README.md @@ -89,7 +89,7 @@ git submodule update ```bash git clone https://gitlab.eurecom.fr/mosaic5g/flexric flexric cd flexric/ -git checkout 7a55f02efaa81fe143280ad49b92cfbfc0cd3320 +git checkout 7278684d3c9d555fb652f8f188afe4ed838d55be ``` ### 2.2.2 Build FlexRIC diff --git a/openair2/E2AP/flexric b/openair2/E2AP/flexric index 2e49853d98..7278684d3c 160000 --- a/openair2/E2AP/flexric +++ b/openair2/E2AP/flexric @@ -1 +1 @@ -Subproject commit 2e49853d9843597c0d61eca6651bcfc4e0166c3f +Subproject commit 7278684d3c9d555fb652f8f188afe4ed838d55be From 3fbc20412ace4d6684db8cc1540b200c50edcf16 Mon Sep 17 00:00:00 2001 From: mir Date: Thu, 5 Oct 2023 15:04:47 +0200 Subject: [PATCH 37/47] Bug in j and i idx --- openair2/E2AP/README.md | 2 +- openair2/E2AP/flexric | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/openair2/E2AP/README.md b/openair2/E2AP/README.md index 7fa1150edf..9042e5ed79 100644 --- a/openair2/E2AP/README.md +++ b/openair2/E2AP/README.md @@ -89,7 +89,7 @@ git submodule update ```bash git clone https://gitlab.eurecom.fr/mosaic5g/flexric flexric cd flexric/ -git checkout 7278684d3c9d555fb652f8f188afe4ed838d55be +git checkout 035fd2e8f9a9d2c16df8d44c9e8c13ccddf9ff19 ``` ### 2.2.2 Build FlexRIC diff --git a/openair2/E2AP/flexric b/openair2/E2AP/flexric index 7278684d3c..035fd2e8f9 160000 --- a/openair2/E2AP/flexric +++ b/openair2/E2AP/flexric @@ -1 +1 @@ -Subproject commit 7278684d3c9d555fb652f8f188afe4ed838d55be +Subproject commit 035fd2e8f9a9d2c16df8d44c9e8c13ccddf9ff19 From 8934c7db1017991dfc6d767ef0f7524e87e91d81 Mon Sep 17 00:00:00 2001 From: francescomani Date: Thu, 5 Oct 2023 18:09:02 +0200 Subject: [PATCH 38/47] fix the selection of DCI candidates at UE --- .../NR_MAC_UE/nr_ue_dci_configuration.c | 42 ++++++++++++------- 1 file changed, 26 insertions(+), 16 deletions(-) diff --git a/openair2/LAYER2/NR_MAC_UE/nr_ue_dci_configuration.c b/openair2/LAYER2/NR_MAC_UE/nr_ue_dci_configuration.c index 7055f2729d..d89dc44ef3 100644 --- a/openair2/LAYER2/NR_MAC_UE/nr_ue_dci_configuration.c +++ b/openair2/LAYER2/NR_MAC_UE/nr_ue_dci_configuration.c @@ -46,34 +46,44 @@ void fill_dci_search_candidates(const NR_SearchSpace_t *ss, { LOG_D(NR_MAC,"Filling search candidates for DCI\n"); - rel15->number_of_candidates = 0; int i = 0; for (int maxL = 16; maxL > 0; maxL >>= 1) { - uint8_t aggregation, number_of_candidates; + uint8_t aggregation, max_number_of_candidates; find_aggregation_candidates(&aggregation, - &number_of_candidates, + &max_number_of_candidates, ss, maxL); - if (number_of_candidates > 0) { - LOG_D(NR_MAC,"L %d, number of candidates %d, aggregation %d\n", maxL, number_of_candidates, aggregation); - int N_cce_sym = 0; // nb of rbs of coreset per symbol - for (int f = 0; f < 6; f++) { - for (int t = 0; t < 8; t++) { - N_cce_sym += ((rel15->coreset.frequency_domain_resource[f] >> t) & 1); + if (max_number_of_candidates == 0) + continue; + LOG_D(NR_MAC,"L %d, max number of candidates %d, aggregation %d\n", maxL, max_number_of_candidates, aggregation); + int N_cce_sym = 0; // nb of rbs of coreset per symbol + for (int f = 0; f < 6; f++) { + for (int t = 0; t < 8; t++) { + N_cce_sym += ((rel15->coreset.frequency_domain_resource[f] >> t) & 1); + } + } + int N_cces = N_cce_sym * rel15->coreset.duration; + if (N_cces < aggregation) + continue; + for (int j = 0; j < max_number_of_candidates; j++) { + int first_cce = aggregation * ((Y + ((j * N_cces) / (aggregation * max_number_of_candidates)) + 0) % (N_cces / aggregation)); + LOG_D(NR_MAC,"Candidate %d of %d first_cce %d (L %d N_cces %d Y %d)\n", j, max_number_of_candidates, first_cce, aggregation, N_cces, Y); + // to avoid storing more than one candidate with the same aggregation and starting CCE (duplicated candidate) + bool duplicated = false; + for (int k = 0; k < i; k++) { + if (rel15->CCE[k] == first_cce && rel15->L[k] == aggregation) { + duplicated = true; + LOG_D(NR_MAC, "Candidate %d of %d is duplicated\n", j, max_number_of_candidates); } } - int N_cces = N_cce_sym * rel15->coreset.duration; - // limit the number of candidates to the ones fitting current configuration - int max_candidates = min(N_cces / aggregation, number_of_candidates); - rel15->number_of_candidates += max_candidates; - for (int j = 0; j < max_candidates; i++, j++) { - int first_cce = aggregation * ((Y + ((j * N_cces) / (aggregation * number_of_candidates)) + 0) % (N_cces / aggregation)); - LOG_D(NR_MAC,"Candidate %d of %d first_cce %d (L %d N_cces %d Y %d)\n", j, max_candidates, first_cce, aggregation, N_cces, Y); + if (!duplicated) { rel15->CCE[i] = first_cce; rel15->L[i] = aggregation; + i++; } } } + rel15->number_of_candidates = i; } NR_ControlResourceSet_t *ue_get_coreset(const NR_UE_MAC_INST_t *mac, const int coreset_id) From f8c122a7cf45182980874bd32d0990e6ac1cbe30 Mon Sep 17 00:00:00 2001 From: Laurent THOMAS Date: Wed, 4 Oct 2023 19:24:03 +0200 Subject: [PATCH 39/47] increase the max fd of rfsim, that have been shorten to tightly for cpu saving --- radio/rfsimulator/simulator.c | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/radio/rfsimulator/simulator.c b/radio/rfsimulator/simulator.c index 34b75fa0a0..9b38ab7026 100644 --- a/radio/rfsimulator/simulator.c +++ b/radio/rfsimulator/simulator.c @@ -70,7 +70,6 @@ #define sampleToByte(a,b) ((a)*(b)*sizeof(sample_t)) #define byteToSample(a,b) ((a)/(sizeof(sample_t)*(b))) -#define MAX_SIMULATION_CONNECTED_NODES 5 #define GENERATE_CHANNEL 10 // each frame (or slot?) in DL // This needs to be re-architected in the future @@ -86,7 +85,7 @@ // FD_SETSIE) and reduced to 125. This should allow for around 20 simultaeous UEs. // // #define MAX_FD_RFSIMU FD_SETSIZE -#define MAX_FD_RFSIMU 125 +#define MAX_FD_RFSIMU 250 #define SYSCTL_MEM_VALUE 134217728 // Kernel network buffer size #define SEND_BUFF_SIZE SYSCTL_MEM_VALUE // Socket buffer size @@ -803,7 +802,7 @@ static bool flushInput(rfsimulator_state_t *t, int timeout, int nsamps_for_initi for ( int i=0; i < t->tx_num_channels; i++) samplesVoid[i]=(void *)&v; - rfsimulator_write_internal(t, t->lastWroteTS > 1 ? t->lastWroteTS - 1 : 0, samplesVoid, 1, t->tx_num_channels, 1, true); + rfsimulator_write_internal(t, t->lastWroteTS > 1 ? t->lastWroteTS - 1 : 0, samplesVoid, 1, t->tx_num_channels, 1, false); } else { if ( events[nbEv].events & (EPOLLHUP | EPOLLERR | EPOLLRDHUP) ) { socketError(t,fd); @@ -963,7 +962,7 @@ static int rfsimulator_read(openair0_device *device, openair0_timestamp *ptimest "Waiting on socket, current last ts: %ld, expected at least : %ld\n", b->lastReceivedTS, t->nextRxTstamp + nsamps); - flushInput(t, 1000, nsamps); // was 3 + flushInput(t, 3, nsamps); } } while (have_to_wait); } From 21795b3b88cbb3f48c28d546a342f864ad7313f1 Mon Sep 17 00:00:00 2001 From: Robert Schmidt Date: Thu, 5 Oct 2023 12:35:51 +0200 Subject: [PATCH 40/47] Correctly encode NRCGI in F1 UE Ctxt Modif Req The two hardcoded PLMNs are never executed: they are in an if(0) block --- openair2/F1AP/f1ap_cu_ue_context_management.c | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/openair2/F1AP/f1ap_cu_ue_context_management.c b/openair2/F1AP/f1ap_cu_ue_context_management.c index 1fb4981330..876cd1e3a9 100644 --- a/openair2/F1AP/f1ap_cu_ue_context_management.c +++ b/openair2/F1AP/f1ap_cu_ue_context_management.c @@ -957,9 +957,7 @@ int CU_send_UE_CONTEXT_MODIFICATION_REQUEST(instance_t instance, f1ap_ue_context F1AP_UEContextModificationRequest_t *out; uint8_t *buffer=NULL; uint32_t len=0; - // for test - LOG_W(F1AP, "UE Context Modification Request PLMN is hardcoded!\n"); - f1ap_served_cell_info_t hardCoded= { .plmn.mcc=208, .plmn.mnc=93, .plmn.mnc_digit_length=2}; + /* Create */ /* 0. Message Type */ pdu.present = F1AP_F1AP_PDU_PR_initiatingMessage; @@ -985,13 +983,18 @@ int CU_send_UE_CONTEXT_MODIFICATION_REQUEST(instance_t instance, f1ap_ue_context /* optional */ /* c3. NRCGI */ - if (0) { + if (true) { asn1cSequenceAdd(out->protocolIEs.list, F1AP_UEContextModificationRequestIEs_t, ie3); ie3->id = F1AP_ProtocolIE_ID_id_SpCell_ID; ie3->criticality = F1AP_Criticality_ignore; ie3->value.present = F1AP_UEContextModificationRequestIEs__value_PR_NRCGI; /* - nRCGI */ - addnRCGI(ie3->value.choice.NRCGI, &hardCoded); + + f1ap_served_cell_info_t nrcgi = { + .plmn = f1ap_ue_context_modification_req->plmn, + .nr_cellid = f1ap_ue_context_modification_req->nr_cellid, + }; + addnRCGI(ie3->value.choice.NRCGI, &nrcgi); } /* optional */ @@ -1113,6 +1116,7 @@ int CU_send_UE_CONTEXT_MODIFICATION_REQUEST(instance_t instance, f1ap_ue_context F1AP_SCell_ToBeSetupMod_Item_t *scell_toBeSetupMod_item= &scell_toBeSetupMod_item_ies->value.choice.SCell_ToBeSetupMod_Item; // /* - sCell_ID */ + f1ap_served_cell_info_t hardCoded = {0}; addnRCGI(scell_toBeSetupMod_item->sCell_ID, &hardCoded); /* sCellIndex */ scell_toBeSetupMod_item->sCellIndex = 6; // issue here @@ -1140,6 +1144,7 @@ int CU_send_UE_CONTEXT_MODIFICATION_REQUEST(instance_t instance, f1ap_ue_context F1AP_SCell_ToBeRemoved_Item_t *scell_toBeRemoved_item= &scell_toBeRemoved_item_ies->value.choice.SCell_ToBeRemoved_Item; /* - sCell_ID */ + f1ap_served_cell_info_t hardCoded = {0}; addnRCGI(scell_toBeRemoved_item->sCell_ID, &hardCoded); } } From 84ffd14a8fa3f23f516bc7afc4132cd504a8fb86 Mon Sep 17 00:00:00 2001 From: Robert Schmidt Date: Thu, 5 Oct 2023 12:36:26 +0200 Subject: [PATCH 41/47] Correctly handle UE Ctxt Modif RRC container The RRC container is to be handled by the msg handler in mac_rrc_dl_handler.c. Therefore, don't forward the RRC message, but copy it into the message so the handler can take the action. --- openair2/F1AP/f1ap_du_ue_context_management.c | 11 +---------- 1 file changed, 1 insertion(+), 10 deletions(-) diff --git a/openair2/F1AP/f1ap_du_ue_context_management.c b/openair2/F1AP/f1ap_du_ue_context_management.c index b9d29303f0..851ced9176 100644 --- a/openair2/F1AP/f1ap_du_ue_context_management.c +++ b/openair2/F1AP/f1ap_du_ue_context_management.c @@ -927,16 +927,7 @@ int DU_handle_UE_CONTEXT_MODIFICATION_REQUEST(instance_t instance, sctp_assoc_t f1ap_ue_context_modification_req->rrc_container = malloc(ieRRC->value.choice.RRCContainer.size); memcpy(f1ap_ue_context_modification_req->rrc_container, ieRRC->value.choice.RRCContainer.buf, ieRRC->value.choice.RRCContainer.size); - protocol_ctxt_t ctxt; - // decode RRC Container and act on the message type - ctxt.rntiMaybeUEid = f1ap_ue_context_modification_req->gNB_DU_ue_id; - ctxt.instance = instance; - ctxt.module_id = instance; - ctxt.enb_flag = 1; - ctxt.eNB_index = instance; - mem_block_t *pdcp_pdu_p = get_free_mem_block(ieRRC->value.choice.RRCContainer.size, __func__); - memcpy(&pdcp_pdu_p->data[0], ieRRC->value.choice.RRCContainer.buf, ieRRC->value.choice.RRCContainer.size); - du_rlc_data_req(&ctxt, 1, 0x00, 1, 1, 0, ieRRC->value.choice.RRCContainer.size, pdcp_pdu_p); + f1ap_ue_context_modification_req->rrc_container_length = ieRRC->value.choice.RRCContainer.size; } else { LOG_E(F1AP, " RRCContainer in UEContextModificationRequestIEs size id 0\n"); } From 68a82e0b7dbbbbeaa2132e13b484d24728f9563c Mon Sep 17 00:00:00 2001 From: Robert Schmidt Date: Thu, 5 Oct 2023 14:22:14 +0200 Subject: [PATCH 42/47] F1 Initial UL RRC message: fill PLMN and Cell ID --- openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_primitives.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_primitives.c b/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_primitives.c index b9bb149310..154c4d072a 100644 --- a/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_primitives.c +++ b/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_primitives.c @@ -2916,8 +2916,11 @@ void send_initial_ul_rrc_message(gNB_MAC_INST *mac, int rnti, const uint8_t *sdu uint8_t du2cu[1024]; int encoded = encode_cellGroupConfig(UE->CellGroup, du2cu, sizeof(du2cu)); + DevAssert(mac->f1_config.setup_req != NULL); + AssertFatal(mac->f1_config.setup_req->num_cells_available == 1, "can handle only one cell\n"); const f1ap_initial_ul_rrc_message_t ul_rrc_msg = { - /* TODO: add mcc, mnc, cell_id, ..., is not available at MAC yet */ + .plmn = mac->f1_config.setup_req->cell[0].info.plmn, + .nr_cellid = mac->f1_config.setup_req->cell[0].info.nr_cellid, .gNB_DU_ue_id = rnti, .crnti = rnti, .rrc_container = (uint8_t *) sdu, From f451f62c9ca00b6ce72b6b4de662f491da263b47 Mon Sep 17 00:00:00 2001 From: Quency Lin Date: Fri, 6 Oct 2023 16:39:51 +0200 Subject: [PATCH 43/47] Fix cannot pass sanitizer, Align to 16 for 2 contiguous 256 SIMDe --- openair1/PHY/INIT/nr_init.c | 2 +- openair1/PHY/NR_TRANSPORT/nr_ulsch_demodulation.c | 10 ++++------ 2 files changed, 5 insertions(+), 7 deletions(-) diff --git a/openair1/PHY/INIT/nr_init.c b/openair1/PHY/INIT/nr_init.c index 9cf5e26cc7..e984384b15 100644 --- a/openair1/PHY/INIT/nr_init.c +++ b/openair1/PHY/INIT/nr_init.c @@ -686,7 +686,7 @@ int phy_init_nr_gNB(PHY_VARS_gNB *gNB) int n_buf = Prx*max_ul_mimo_layers; int nb_re_pusch = N_RB_UL * NR_NB_SC_PER_RB; - int nb_re_pusch2 = (nb_re_pusch + 7) & ~7; + int nb_re_pusch2 = (nb_re_pusch + 15) & ~15; gNB->pusch_vars = (NR_gNB_PUSCH *)malloc16_clear(gNB->max_nb_pusch * sizeof(NR_gNB_PUSCH)); for (int ULSCH_id = 0; ULSCH_id < gNB->max_nb_pusch; ULSCH_id++) { diff --git a/openair1/PHY/NR_TRANSPORT/nr_ulsch_demodulation.c b/openair1/PHY/NR_TRANSPORT/nr_ulsch_demodulation.c index 18aea849f7..afa1dac143 100644 --- a/openair1/PHY/NR_TRANSPORT/nr_ulsch_demodulation.c +++ b/openair1/PHY/NR_TRANSPORT/nr_ulsch_demodulation.c @@ -1146,9 +1146,8 @@ static uint8_t nr_ulsch_mmse_2layers(NR_DL_FRAME_PARMS *frame_parms, simde__m128i *after_mf_c_128 = (simde__m128i *)af_mf_10; simde__m128i *after_mf_d_128 = (simde__m128i *)af_mf_11; - int rxComp_aligned = ((nb_rb * 12) % 8) ? (8 - (nb_rb * 12) % 8) : 0; - simde__m128i *rxdataF_comp128_0 = (simde__m128i *)&rxdataF_comp[0][symbol * (nb_rb * 12 + rxComp_aligned)]; - simde__m128i *rxdataF_comp128_1 = (simde__m128i *)&rxdataF_comp[n_rx][symbol * (nb_rb * 12 + rxComp_aligned)]; + simde__m128i *rxdataF_comp128_0 = (simde__m128i *)&rxdataF_comp[0][symbol * buffer_length]; + simde__m128i *rxdataF_comp128_1 = (simde__m128i *)&rxdataF_comp[n_rx][symbol * buffer_length]; if (mod_order > 2) { if (mod_order == 4) { @@ -1277,7 +1276,7 @@ static void inner_rx (PHY_VARS_gNB *gNB, int nb_layer = rel15_ul->nrOfLayers; int nb_rx_ant = frame_parms->nb_antennas_rx; int dmrs_symbol_flag = (rel15_ul->ul_dmrs_symb_pos >> symbol) & 0x01; - int buffer_length = (rel15_ul->rb_size * NR_NB_SC_PER_RB + 7) & ~7; + int buffer_length = (rel15_ul->rb_size * NR_NB_SC_PER_RB + 15) & ~15; c16_t rxFext[nb_rx_ant][buffer_length] __attribute__((aligned(32))); c16_t chFext[nb_layer][nb_rx_ant][buffer_length] __attribute__((aligned(32))); @@ -1578,8 +1577,7 @@ int nr_rx_pusch_tp(PHY_VARS_gNB *gNB, // extract the data in the OFDM frame, to the start of the array int soffset = (slot&3)*frame_parms->symbols_per_slot*frame_parms->ofdm_symbol_size; - if (nb_re_pusch & 7) - nb_re_pusch += 8 - (nb_re_pusch & 7); + nb_re_pusch = (nb_re_pusch + 15) & ~15; for (int aarx = 0; aarx < frame_parms->nb_antennas_rx; aarx++) for (int aatx = 0; aatx < rel15_ul->nrOfLayers; aatx++) From 584fb235cd9007c17a464901460f7d8bb1ac04d7 Mon Sep 17 00:00:00 2001 From: Laurent THOMAS Date: Fri, 6 Oct 2023 18:00:18 +0200 Subject: [PATCH 44/47] remove-dead-code-nrue --- openair1/PHY/INIT/nr_init.c | 39 ---------------------- openair1/PHY/defs_gNB.h | 40 ----------------------- openair1/SCHED_NR/phy_procedures_nr_gNB.c | 12 ------- openair1/SIMULATION/NR_PHY/ulsim.c | 12 ------- 4 files changed, 103 deletions(-) diff --git a/openair1/PHY/INIT/nr_init.c b/openair1/PHY/INIT/nr_init.c index 9cf5e26cc7..1d5b732529 100644 --- a/openair1/PHY/INIT/nr_init.c +++ b/openair1/PHY/INIT/nr_init.c @@ -697,24 +697,9 @@ int phy_init_nr_gNB(PHY_VARS_gNB *gNB) pusch->ptrs_phase_per_slot = (int32_t **)malloc16(n_buf * sizeof(int32_t *)); pusch->ul_ch_estimates_time = (int32_t **)malloc16(n_buf * sizeof(int32_t *)); pusch->rxdataF_comp = (int32_t **)malloc16(n_buf * sizeof(int32_t *)); - pusch->ul_ch_mag0 = (int32_t **)malloc16(n_buf * sizeof(int32_t *)); - pusch->ul_ch_magb0 = (int32_t **)malloc16(n_buf * sizeof(int32_t *)); - pusch->ul_ch_magc0 = (int32_t **)malloc16(n_buf * sizeof(int32_t *)); - pusch->ul_ch_mag = (int32_t **)malloc16(n_buf * sizeof(int32_t *)); - pusch->ul_ch_magb = (int32_t **)malloc16(n_buf * sizeof(int32_t *)); - pusch->ul_ch_magc = (int32_t **)malloc16(n_buf * sizeof(int32_t *)); - pusch->rho = (int32_t ***)malloc16(Prx * sizeof(int32_t **)); pusch->llr_layers = (int16_t **)malloc16(max_ul_mimo_layers * sizeof(int32_t *)); for (i = 0; i < Prx; i++) { pusch->rxdataF_ext[i] = (int32_t *)malloc16_clear(sizeof(int32_t) * nb_re_pusch2 * fp->symbols_per_slot); - pusch->rho[i] = (int32_t **)malloc16_clear(NR_MAX_NB_LAYERS * NR_MAX_NB_LAYERS * sizeof(int32_t *)); - - for (int j = 0; j < max_ul_mimo_layers; j++) { - for (int k = 0; k < max_ul_mimo_layers; k++) { - pusch->rho[i][j * max_ul_mimo_layers + k] = - (int32_t *)malloc16_clear(sizeof(int32_t) * nb_re_pusch2 * fp->symbols_per_slot); - } - } } for (i = 0; i < n_buf; i++) { pusch->ul_ch_estimates[i] = (int32_t *)malloc16_clear(sizeof(int32_t) * fp->ofdm_symbol_size * fp->symbols_per_slot); @@ -722,12 +707,6 @@ int phy_init_nr_gNB(PHY_VARS_gNB *gNB) pusch->ul_ch_estimates_time[i] = (int32_t *)malloc16_clear(sizeof(int32_t) * fp->ofdm_symbol_size); pusch->ptrs_phase_per_slot[i] = (int32_t *)malloc16_clear(sizeof(int32_t) * fp->symbols_per_slot); // symbols per slot pusch->rxdataF_comp[i] = (int32_t *)malloc16_clear(sizeof(int32_t) * nb_re_pusch2 * fp->symbols_per_slot); - pusch->ul_ch_mag0[i] = (int32_t *)malloc16_clear(sizeof(int32_t) * nb_re_pusch2 * fp->symbols_per_slot); - pusch->ul_ch_magb0[i] = (int32_t *)malloc16_clear(sizeof(int32_t) * nb_re_pusch2 * fp->symbols_per_slot); - pusch->ul_ch_magc0[i] = (int32_t *)malloc16_clear(sizeof(int32_t) * nb_re_pusch2 * fp->symbols_per_slot); - pusch->ul_ch_mag[i] = (int32_t *)malloc16_clear(sizeof(int32_t) * nb_re_pusch2 * fp->symbols_per_slot); - pusch->ul_ch_magb[i] = (int32_t *)malloc16_clear(sizeof(int32_t) * nb_re_pusch2 * fp->symbols_per_slot); - pusch->ul_ch_magc[i] = (int32_t *)malloc16_clear(sizeof(int32_t) * nb_re_pusch2 * fp->symbols_per_slot); } for (i=0; i< max_ul_mimo_layers; i++) { @@ -851,11 +830,6 @@ void phy_free_nr_gNB(PHY_VARS_gNB *gNB) free_and_zero(pusch_vars->llr_layers[i]); for (int i = 0; i < Prx; i++) { free_and_zero(pusch_vars->rxdataF_ext[i]); - for (int j=0; j< max_ul_mimo_layers; j++) { - for (int k=0; krho[i][j * max_ul_mimo_layers + k]); - } - free_and_zero(pusch_vars->rho[i]); } for (int i = 0; i < n_buf; i++) { free_and_zero(pusch_vars->ul_ch_estimates[i]); @@ -863,12 +837,6 @@ void phy_free_nr_gNB(PHY_VARS_gNB *gNB) free_and_zero(pusch_vars->ul_ch_estimates_time[i]); free_and_zero(pusch_vars->ptrs_phase_per_slot[i]); free_and_zero(pusch_vars->rxdataF_comp[i]); - free_and_zero(pusch_vars->ul_ch_mag0[i]); - free_and_zero(pusch_vars->ul_ch_magb0[i]); - free_and_zero(pusch_vars->ul_ch_magc0[i]); - free_and_zero(pusch_vars->ul_ch_mag[i]); - free_and_zero(pusch_vars->ul_ch_magb[i]); - free_and_zero(pusch_vars->ul_ch_magc[i]); } free_and_zero(pusch_vars->llr_layers); free_and_zero(pusch_vars->rxdataF_ext); @@ -878,13 +846,6 @@ void phy_free_nr_gNB(PHY_VARS_gNB *gNB) free_and_zero(pusch_vars->ul_ch_estimates_time); free_and_zero(pusch_vars->ul_valid_re_per_slot); free_and_zero(pusch_vars->rxdataF_comp); - free_and_zero(pusch_vars->ul_ch_mag0); - free_and_zero(pusch_vars->ul_ch_magb0); - free_and_zero(pusch_vars->ul_ch_magc0); - free_and_zero(pusch_vars->ul_ch_mag); - free_and_zero(pusch_vars->ul_ch_magb); - free_and_zero(pusch_vars->ul_ch_magc); - free_and_zero(pusch_vars->rho); free_and_zero(pusch_vars->llr); } // ULSCH_id diff --git a/openair1/PHY/defs_gNB.h b/openair1/PHY/defs_gNB.h index 5252d7a4e3..ae2ce9d0a7 100644 --- a/openair1/PHY/defs_gNB.h +++ b/openair1/PHY/defs_gNB.h @@ -345,48 +345,8 @@ typedef struct { /// - first index: rx antenna id [0..nb_antennas_rx[ /// - second index: ? [0..12*N_RB_UL*frame_parms->symbols_per_tti[ int32_t **rxdataF_comp; - /// \brief Magnitude of the UL channel estimates. Used for 2nd-bit level thresholds in LLR computation - /// - first index: rx antenna id [0..nb_antennas_rx[ - /// - second index: ? [0..12*N_RB_UL*frame_parms->symbols_per_tti[ - int32_t **ul_ch_mag; - /// \brief Magnitude of the UL channel estimates scaled for 3rd bit level thresholds in LLR computation - /// - first index: rx antenna id [0..nb_antennas_rx[ - /// - second index: ? [0..12*N_RB_UL*frame_parms->symbols_per_tti[ - int32_t **ul_ch_magb; - /// \brief Magnitude of the UL channel estimates scaled for 4th bit level thresholds in LLR computation - /// - first index: rx antenna id [0..nb_antennas_rx[ - /// - second index: ? [0..12*N_RB_UL*frame_parms->symbols_per_tti[ - int32_t **ul_ch_magc; - /// \brief Cross-correlation of two UE signals. - /// - first index: rx antenna [0..nb_antennas_rx[ - /// - second index: symbol [0..] - int32_t ***rho; /// \f$\log_2(\max|H_i|^2)\f$ int16_t log2_maxh; - /// \brief Magnitude of Uplink Channel first layer (16QAM level/First 64QAM level/First 256QAM level). - /// - first index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx - /// - second index: ? [0..168*N_RB_UL[ - int32_t **ul_ch_mag0; - /// \brief Magnitude of Uplink Channel second layer (16QAM level/First 64QAM level/First 256QAM level). - /// - first index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx - /// - second index: ? [0..168*N_RB_UL[ - int32_t **ul_ch_mag1[8][8]; - /// \brief Magnitude of Uplink Channel, first layer (2nd 64QAM/256QAM level). - /// - first index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx - /// - second index: ? [0..168*N_RB_UL[ - int32_t **ul_ch_magb0; - /// \brief Magnitude of Uplink Channel second layer (2nd 64QAM/256QAM level). - /// - first index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx - /// - second index: ? [0..168*N_RB_UL[ - int32_t **ul_ch_magb1[8][8]; - /// \brief Magnitude of Uplink Channel, first layer (3rd 256QAM level). - /// - first index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx - /// - second index: ? [0..168*N_RB_UL[ - int32_t **ul_ch_magc0; - /// \brief Magnitude of Uplink Channel second layer (3rd 256QAM level). - /// - first index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx - /// - second index: ? [0..168*N_RB_UL[ - int32_t **ul_ch_magc1[8][8]; /// measured RX power based on DRS int ulsch_power[8]; /// total signal over antennas diff --git a/openair1/SCHED_NR/phy_procedures_nr_gNB.c b/openair1/SCHED_NR/phy_procedures_nr_gNB.c index cf47c699d9..b98de5a1f8 100644 --- a/openair1/SCHED_NR/phy_procedures_nr_gNB.c +++ b/openair1/SCHED_NR/phy_procedures_nr_gNB.c @@ -465,12 +465,6 @@ void nr_fill_indication(PHY_VARS_gNB *gNB, int frame, int slot_rx, int ULSCH_id, int off = ((pusch_pdu->rb_size&1) == 1)? 4:0; LOG_M("rxsigF0.m","rxsF0",&gNB->common_vars.rxdataF[0][(slot_rx&3)*gNB->frame_parms.ofdm_symbol_size*gNB->frame_parms.symbols_per_slot],gNB->frame_parms.ofdm_symbol_size*gNB->frame_parms.symbols_per_slot,1,1); - LOG_M("rxsigF0_ext.m", - "rxsF0_ext", - &gNB->pusch_vars[0].rxdataF_ext[0][pusch_pdu->start_symbol_index * NR_NB_SC_PER_RB * pusch_pdu->rb_size], - pusch_pdu->nr_of_symbols * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size)), - 1, - 1); LOG_M("chestF0.m", "chF0", &gNB->pusch_vars[0].ul_ch_estimates[0][pusch_pdu->start_symbol_index * gNB->frame_parms.ofdm_symbol_size], @@ -498,12 +492,6 @@ void nr_fill_indication(PHY_VARS_gNB *gNB, int frame, int slot_rx, int ULSCH_id, 0); if (gNB->frame_parms.nb_antennas_rx > 1) { LOG_M("rxsigF1.m","rxsF1",&gNB->common_vars.rxdataF[1][(slot_rx&3)*gNB->frame_parms.ofdm_symbol_size*gNB->frame_parms.symbols_per_slot],gNB->frame_parms.ofdm_symbol_size*gNB->frame_parms.symbols_per_slot,1,1); - LOG_M("rxsigF1_ext.m", - "rxsF1_ext", - &gNB->pusch_vars[0].rxdataF_ext[1][pusch_pdu->start_symbol_index * NR_NB_SC_PER_RB * pusch_pdu->rb_size], - pusch_pdu->nr_of_symbols * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size)), - 1, - 1); LOG_M("chestF1.m", "chF1", &gNB->pusch_vars[0].ul_ch_estimates[1][pusch_pdu->start_symbol_index * gNB->frame_parms.ofdm_symbol_size], diff --git a/openair1/SIMULATION/NR_PHY/ulsim.c b/openair1/SIMULATION/NR_PHY/ulsim.c index 762487c759..5fd35cfd6c 100644 --- a/openair1/SIMULATION/NR_PHY/ulsim.c +++ b/openair1/SIMULATION/NR_PHY/ulsim.c @@ -1296,18 +1296,6 @@ int main(int argc, char *argv[]) nb_symb_sch * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size)), 1, 1); - LOG_M("chmagF0.m", - "chmF0", - &pusch_vars->ul_ch_mag[0][start_symbol * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size))], - nb_symb_sch * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size)), - 1, - 1); - LOG_M("chmagbF0.m", - "chmbF0", - &pusch_vars->ul_ch_magb[0][start_symbol * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size))], - nb_symb_sch * (off + (NR_NB_SC_PER_RB * pusch_pdu->rb_size)), - 1, - 1); LOG_M("rxsigF0_llrlayers0.m", "rxsF0_llrlayers0", &pusch_vars->llr_layers[0][0], From aaef0b5e747b79c6967b6b12222056204789fb65 Mon Sep 17 00:00:00 2001 From: Robert Schmidt Date: Thu, 5 Oct 2023 14:21:54 +0200 Subject: [PATCH 45/47] F1 UE Ctxt Modif Req: forward Capabilities, ignore other CU2DU - forward capabilities to update CellGroupConfig - Do not require measConfig/cG_ConfigInfo to be NULL, but ignore them, as it is not implemented --- openair2/F1AP/f1ap_du_ue_context_management.c | 26 +++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/openair2/F1AP/f1ap_du_ue_context_management.c b/openair2/F1AP/f1ap_du_ue_context_management.c index 851ced9176..91cb157c9d 100644 --- a/openair2/F1AP/f1ap_du_ue_context_management.c +++ b/openair2/F1AP/f1ap_du_ue_context_management.c @@ -935,6 +935,32 @@ int DU_handle_UE_CONTEXT_MODIFICATION_REQUEST(instance_t instance, sctp_assoc_t LOG_D(F1AP, "can't find RRCContainer in UEContextModificationRequestIEs by id %ld \n", F1AP_ProtocolIE_ID_id_RRCContainer); } + /* CU2DU Information */ + F1AP_UEContextModificationRequestIEs_t *ieCU2DU = NULL; + F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_UEContextModificationRequestIEs_t, + ieCU2DU, + container, + F1AP_ProtocolIE_ID_id_CUtoDURRCInformation, + false); + if (ieCU2DU != NULL) { + f1ap_ue_context_modification_req->cu_to_du_rrc_information = + calloc(1, sizeof(*f1ap_ue_context_modification_req->cu_to_du_rrc_information)); + AssertFatal(f1ap_ue_context_modification_req->cu_to_du_rrc_information != NULL, "out of memory\n"); + cu_to_du_rrc_information_t *cu2du = f1ap_ue_context_modification_req->cu_to_du_rrc_information; + const F1AP_CUtoDURRCInformation_t *cu2duie = &ieCU2DU->value.choice.CUtoDURRCInformation; + if (cu2duie->cG_ConfigInfo != NULL) + LOG_W(F1AP, "UE RNTI %04x: ignoring cg_ConfigInfo, not implemented\n", f1ap_ue_context_modification_req->gNB_DU_ue_id); + if (cu2duie->measConfig != NULL) + LOG_W(F1AP, "UE RNTI %04x: ignoring measConfig, not implemented\n", f1ap_ue_context_modification_req->gNB_DU_ue_id); + if (cu2duie->uE_CapabilityRAT_ContainerList != NULL) { + F1AP_UE_CapabilityRAT_ContainerList_t *uecap = cu2duie->uE_CapabilityRAT_ContainerList; + cu2du->uE_CapabilityRAT_ContainerList = calloc(uecap->size, sizeof(*cu2du->uE_CapabilityRAT_ContainerList)); + AssertFatal(cu2du->uE_CapabilityRAT_ContainerList != NULL, "out of memory\n"); + cu2du->uE_CapabilityRAT_ContainerList_length = uecap->size; + memcpy(cu2du->uE_CapabilityRAT_ContainerList, uecap->buf, uecap->size); + } + } + ue_context_modification_request(f1ap_ue_context_modification_req); return 0; } From 4066fd4ba280173be300e4e354ef3db315978941 Mon Sep 17 00:00:00 2001 From: Robert Schmidt Date: Thu, 5 Oct 2023 14:22:38 +0200 Subject: [PATCH 46/47] UE Context Modification Handler: also trigger CellConfig if only UE Capability changes --- openair2/LAYER2/NR_MAC_gNB/mac_rrc_dl_handler.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/openair2/LAYER2/NR_MAC_gNB/mac_rrc_dl_handler.c b/openair2/LAYER2/NR_MAC_gNB/mac_rrc_dl_handler.c index e18c9ea5b7..ea0d08e152 100644 --- a/openair2/LAYER2/NR_MAC_gNB/mac_rrc_dl_handler.c +++ b/openair2/LAYER2/NR_MAC_gNB/mac_rrc_dl_handler.c @@ -369,7 +369,8 @@ void ue_context_modification_request(const f1ap_ue_context_modif_req_t *req) update_cellGroupConfig(new_CellGroup, UE->uid, UE->capability, &mac->radio_config, scc); } - if (req->srbs_to_be_setup_length > 0 || req->drbs_to_be_setup_length > 0 || req->drbs_to_be_released_length > 0) { + if (req->srbs_to_be_setup_length > 0 || req->drbs_to_be_setup_length > 0 || req->drbs_to_be_released_length > 0 + || ue_cap != NULL) { resp.du_to_cu_rrc_information = calloc(1, sizeof(du_to_cu_rrc_information_t)); AssertFatal(resp.du_to_cu_rrc_information != NULL, "out of memory\n"); resp.du_to_cu_rrc_information->cellGroupConfig = calloc(1, 1024); From c3df9c277fa05231431ca44e4cade230a303d4d2 Mon Sep 17 00:00:00 2001 From: Robert Schmidt Date: Sun, 8 Oct 2023 12:27:18 +0200 Subject: [PATCH 47/47] Remove warning about new CellGroupConfig It is *normal* to receive new CellGroupConfigs from the DU, hence a warning is not warranted. --- openair2/RRC/NR/rrc_gNB.c | 1 - 1 file changed, 1 deletion(-) diff --git a/openair2/RRC/NR/rrc_gNB.c b/openair2/RRC/NR/rrc_gNB.c index e5dcc79dfd..f57c7567f5 100644 --- a/openair2/RRC/NR/rrc_gNB.c +++ b/openair2/RRC/NR/rrc_gNB.c @@ -2077,7 +2077,6 @@ static void rrc_CU_process_ue_context_modification_response(MessageDef *msg_p, i } if (resp->du_to_cu_rrc_information != NULL && resp->du_to_cu_rrc_information->cellGroupConfig != NULL) { - LOG_W(RRC, "UE context modification response contains new CellGroupConfig for UE %04x, triggering reconfiguration\n", UE->rnti); NR_CellGroupConfig_t *cellGroupConfig = NULL; asn_dec_rval_t dec_rval = uper_decode_complete(NULL, &asn_DEF_NR_CellGroupConfig,